<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">

<html lang="en">

<head>
  <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
  <title>LCOV - coverage_clean.info - 13/bits/hashtable.h</title>
  <link rel="stylesheet" type="text/css" href="../../gcov.css">
</head>

<body>

          <table width="100%" border=0 cellspacing=0 cellpadding=0>
            <tr><td class="title">LCOV - code coverage report</td></tr>
            <tr><td class="ruler"><img src="../../glass.png" width=3 height=3 alt=""></td></tr>

            <tr>
              <td width="100%">
                <table cellpadding=1 border=0 width="100%">
          <tr>
            <td width="10%" class="headerItem">Current view:</td>
            <td width="10%" class="headerValue"><a href="../../index.html">top level</a> - <a href="index.html">13/bits</a> - hashtable.h<span style="font-size: 80%;"> (source / <a href="hashtable.h.func-c.html">functions</a>)</span></td>
            <td width="5%"></td>
            <td width="5%"></td>
            <td width="5%" class="headerCovTableHead">Coverage</td>
            <td width="5%" class="headerCovTableHead" title="Covered + Uncovered code">Total</td>
            <td width="5%" class="headerCovTableHead" title="Exercised code only">Hit</td>
          </tr>
          <tr>
            <td class="headerItem">Test:</td>
            <td class="headerValue">coverage_clean.info</td>
            <td></td>
            <td class="headerItem">Lines:</td>
            <td class="headerCovTableEntryLo">49.1&nbsp;%</td>
            <td class="headerCovTableEntry">171</td>
            <td class="headerCovTableEntry">84</td>
          </tr>
          <tr>
            <td class="headerItem">Test Date:</td>
            <td class="headerValue">2025-11-25 04:45:29</td>
            <td></td>
            <td class="headerItem">Functions:</td>
            <td class="headerCovTableEntryLo">73.3&nbsp;%</td>
            <td class="headerCovTableEntry">30</td>
            <td class="headerCovTableEntry">22</td>
          </tr>
                  <tr><td><img src="../../glass.png" width=3 height=3 alt=""></td></tr>
                </table>
              </td>
            </tr>

            <tr><td class="ruler"><img src="../../glass.png" width=3 height=3 alt=""></td></tr>
          </table>

          <table cellpadding=0 cellspacing=0 border=0>
            <tr>
              <td><br></td>
            </tr>
            <tr>
              <td>
<pre class="sourceHeading">            Line data    Source code</pre>
<pre class="source">
<span id="L1"><span class="lineNum">       1</span>              : // hashtable.h header -*- C++ -*-</span>
<span id="L2"><span class="lineNum">       2</span>              : </span>
<span id="L3"><span class="lineNum">       3</span>              : // Copyright (C) 2007-2023 Free Software Foundation, Inc.</span>
<span id="L4"><span class="lineNum">       4</span>              : //</span>
<span id="L5"><span class="lineNum">       5</span>              : // This file is part of the GNU ISO C++ Library.  This library is free</span>
<span id="L6"><span class="lineNum">       6</span>              : // software; you can redistribute it and/or modify it under the</span>
<span id="L7"><span class="lineNum">       7</span>              : // terms of the GNU General Public License as published by the</span>
<span id="L8"><span class="lineNum">       8</span>              : // Free Software Foundation; either version 3, or (at your option)</span>
<span id="L9"><span class="lineNum">       9</span>              : // any later version.</span>
<span id="L10"><span class="lineNum">      10</span>              : </span>
<span id="L11"><span class="lineNum">      11</span>              : // This library is distributed in the hope that it will be useful,</span>
<span id="L12"><span class="lineNum">      12</span>              : // but WITHOUT ANY WARRANTY; without even the implied warranty of</span>
<span id="L13"><span class="lineNum">      13</span>              : // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the</span>
<span id="L14"><span class="lineNum">      14</span>              : // GNU General Public License for more details.</span>
<span id="L15"><span class="lineNum">      15</span>              : </span>
<span id="L16"><span class="lineNum">      16</span>              : // Under Section 7 of GPL version 3, you are granted additional</span>
<span id="L17"><span class="lineNum">      17</span>              : // permissions described in the GCC Runtime Library Exception, version</span>
<span id="L18"><span class="lineNum">      18</span>              : // 3.1, as published by the Free Software Foundation.</span>
<span id="L19"><span class="lineNum">      19</span>              : </span>
<span id="L20"><span class="lineNum">      20</span>              : // You should have received a copy of the GNU General Public License and</span>
<span id="L21"><span class="lineNum">      21</span>              : // a copy of the GCC Runtime Library Exception along with this program;</span>
<span id="L22"><span class="lineNum">      22</span>              : // see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see</span>
<span id="L23"><span class="lineNum">      23</span>              : // &lt;http://www.gnu.org/licenses/&gt;.</span>
<span id="L24"><span class="lineNum">      24</span>              : </span>
<span id="L25"><span class="lineNum">      25</span>              : /** @file bits/hashtable.h</span>
<span id="L26"><span class="lineNum">      26</span>              :  *  This is an internal header file, included by other library headers.</span>
<span id="L27"><span class="lineNum">      27</span>              :  *  Do not attempt to use it directly. @headername{unordered_map, unordered_set}</span>
<span id="L28"><span class="lineNum">      28</span>              :  */</span>
<span id="L29"><span class="lineNum">      29</span>              : </span>
<span id="L30"><span class="lineNum">      30</span>              : #ifndef _HASHTABLE_H</span>
<span id="L31"><span class="lineNum">      31</span>              : #define _HASHTABLE_H 1</span>
<span id="L32"><span class="lineNum">      32</span>              : </span>
<span id="L33"><span class="lineNum">      33</span>              : #pragma GCC system_header</span>
<span id="L34"><span class="lineNum">      34</span>              : </span>
<span id="L35"><span class="lineNum">      35</span>              : #include &lt;bits/hashtable_policy.h&gt;</span>
<span id="L36"><span class="lineNum">      36</span>              : #include &lt;bits/enable_special_members.h&gt;</span>
<span id="L37"><span class="lineNum">      37</span>              : #include &lt;bits/stl_function.h&gt; // __has_is_transparent_t</span>
<span id="L38"><span class="lineNum">      38</span>              : #if __cplusplus &gt; 201402L</span>
<span id="L39"><span class="lineNum">      39</span>              : # include &lt;bits/node_handle.h&gt;</span>
<span id="L40"><span class="lineNum">      40</span>              : #endif</span>
<span id="L41"><span class="lineNum">      41</span>              : </span>
<span id="L42"><span class="lineNum">      42</span>              : namespace std _GLIBCXX_VISIBILITY(default)</span>
<span id="L43"><span class="lineNum">      43</span>              : {</span>
<span id="L44"><span class="lineNum">      44</span>              : _GLIBCXX_BEGIN_NAMESPACE_VERSION</span>
<span id="L45"><span class="lineNum">      45</span>              : /// @cond undocumented</span>
<span id="L46"><span class="lineNum">      46</span>              : </span>
<span id="L47"><span class="lineNum">      47</span>              :   template&lt;typename _Tp, typename _Hash&gt;</span>
<span id="L48"><span class="lineNum">      48</span>              :     using __cache_default</span>
<span id="L49"><span class="lineNum">      49</span>              :       =  __not_&lt;__and_&lt;// Do not cache for fast hasher.</span>
<span id="L50"><span class="lineNum">      50</span>              :                        __is_fast_hash&lt;_Hash&gt;,</span>
<span id="L51"><span class="lineNum">      51</span>              :                        // Mandatory to have erase not throwing.</span>
<span id="L52"><span class="lineNum">      52</span>              :                        __is_nothrow_invocable&lt;const _Hash&amp;, const _Tp&amp;&gt;&gt;&gt;;</span>
<span id="L53"><span class="lineNum">      53</span>              : </span>
<span id="L54"><span class="lineNum">      54</span>              :   // Helper to conditionally delete the default constructor.</span>
<span id="L55"><span class="lineNum">      55</span>              :   // The _Hash_node_base type is used to distinguish this specialization</span>
<span id="L56"><span class="lineNum">      56</span>              :   // from any other potentially-overlapping subobjects of the hashtable.</span>
<span id="L57"><span class="lineNum">      57</span>              :   template&lt;typename _Equal, typename _Hash, typename _Allocator&gt;</span>
<span id="L58"><span class="lineNum">      58</span>              :     using _Hashtable_enable_default_ctor</span>
<span id="L59"><span class="lineNum">      59</span>              :       = _Enable_default_constructor&lt;__and_&lt;is_default_constructible&lt;_Equal&gt;,</span>
<span id="L60"><span class="lineNum">      60</span>              :                                        is_default_constructible&lt;_Hash&gt;,</span>
<span id="L61"><span class="lineNum">      61</span>              :                                        is_default_constructible&lt;_Allocator&gt;&gt;{},</span>
<span id="L62"><span class="lineNum">      62</span>              :                                     __detail::_Hash_node_base&gt;;</span>
<span id="L63"><span class="lineNum">      63</span>              : </span>
<span id="L64"><span class="lineNum">      64</span>              :   /**</span>
<span id="L65"><span class="lineNum">      65</span>              :    *  Primary class template _Hashtable.</span>
<span id="L66"><span class="lineNum">      66</span>              :    *</span>
<span id="L67"><span class="lineNum">      67</span>              :    *  @ingroup hashtable-detail</span>
<span id="L68"><span class="lineNum">      68</span>              :    *</span>
<span id="L69"><span class="lineNum">      69</span>              :    *  @tparam _Value  CopyConstructible type.</span>
<span id="L70"><span class="lineNum">      70</span>              :    *</span>
<span id="L71"><span class="lineNum">      71</span>              :    *  @tparam _Key    CopyConstructible type.</span>
<span id="L72"><span class="lineNum">      72</span>              :    *</span>
<span id="L73"><span class="lineNum">      73</span>              :    *  @tparam _Alloc  An allocator type</span>
<span id="L74"><span class="lineNum">      74</span>              :    *  ([lib.allocator.requirements]) whose _Alloc::value_type is</span>
<span id="L75"><span class="lineNum">      75</span>              :    *  _Value.  As a conforming extension, we allow for</span>
<span id="L76"><span class="lineNum">      76</span>              :    *  _Alloc::value_type != _Value.</span>
<span id="L77"><span class="lineNum">      77</span>              :    *</span>
<span id="L78"><span class="lineNum">      78</span>              :    *  @tparam _ExtractKey  Function object that takes an object of type</span>
<span id="L79"><span class="lineNum">      79</span>              :    *  _Value and returns a value of type _Key.</span>
<span id="L80"><span class="lineNum">      80</span>              :    *</span>
<span id="L81"><span class="lineNum">      81</span>              :    *  @tparam _Equal  Function object that takes two objects of type k</span>
<span id="L82"><span class="lineNum">      82</span>              :    *  and returns a bool-like value that is true if the two objects</span>
<span id="L83"><span class="lineNum">      83</span>              :    *  are considered equal.</span>
<span id="L84"><span class="lineNum">      84</span>              :    *</span>
<span id="L85"><span class="lineNum">      85</span>              :    *  @tparam _Hash  The hash function. A unary function object with</span>
<span id="L86"><span class="lineNum">      86</span>              :    *  argument type _Key and result type size_t. Return values should</span>
<span id="L87"><span class="lineNum">      87</span>              :    *  be distributed over the entire range [0, numeric_limits&lt;size_t&gt;:::max()].</span>
<span id="L88"><span class="lineNum">      88</span>              :    *</span>
<span id="L89"><span class="lineNum">      89</span>              :    *  @tparam _RangeHash  The range-hashing function (in the terminology of</span>
<span id="L90"><span class="lineNum">      90</span>              :    *  Tavori and Dreizin).  A binary function object whose argument</span>
<span id="L91"><span class="lineNum">      91</span>              :    *  types and result type are all size_t.  Given arguments r and N,</span>
<span id="L92"><span class="lineNum">      92</span>              :    *  the return value is in the range [0, N).</span>
<span id="L93"><span class="lineNum">      93</span>              :    *</span>
<span id="L94"><span class="lineNum">      94</span>              :    *  @tparam _Unused  Not used.</span>
<span id="L95"><span class="lineNum">      95</span>              :    *</span>
<span id="L96"><span class="lineNum">      96</span>              :    *  @tparam _RehashPolicy  Policy class with three members, all of</span>
<span id="L97"><span class="lineNum">      97</span>              :    *  which govern the bucket count. _M_next_bkt(n) returns a bucket</span>
<span id="L98"><span class="lineNum">      98</span>              :    *  count no smaller than n.  _M_bkt_for_elements(n) returns a</span>
<span id="L99"><span class="lineNum">      99</span>              :    *  bucket count appropriate for an element count of n.</span>
<span id="L100"><span class="lineNum">     100</span>              :    *  _M_need_rehash(n_bkt, n_elt, n_ins) determines whether, if the</span>
<span id="L101"><span class="lineNum">     101</span>              :    *  current bucket count is n_bkt and the current element count is</span>
<span id="L102"><span class="lineNum">     102</span>              :    *  n_elt, we need to increase the bucket count for n_ins insertions.</span>
<span id="L103"><span class="lineNum">     103</span>              :    *  If so, returns make_pair(true, n), where n is the new bucket count. If</span>
<span id="L104"><span class="lineNum">     104</span>              :    *  not, returns make_pair(false, &lt;anything&gt;)</span>
<span id="L105"><span class="lineNum">     105</span>              :    *</span>
<span id="L106"><span class="lineNum">     106</span>              :    *  @tparam _Traits  Compile-time class with three boolean</span>
<span id="L107"><span class="lineNum">     107</span>              :    *  std::integral_constant members:  __cache_hash_code, __constant_iterators,</span>
<span id="L108"><span class="lineNum">     108</span>              :    *   __unique_keys.</span>
<span id="L109"><span class="lineNum">     109</span>              :    *</span>
<span id="L110"><span class="lineNum">     110</span>              :    *  Each _Hashtable data structure has:</span>
<span id="L111"><span class="lineNum">     111</span>              :    *</span>
<span id="L112"><span class="lineNum">     112</span>              :    *  - _Bucket[]       _M_buckets</span>
<span id="L113"><span class="lineNum">     113</span>              :    *  - _Hash_node_base _M_before_begin</span>
<span id="L114"><span class="lineNum">     114</span>              :    *  - size_type       _M_bucket_count</span>
<span id="L115"><span class="lineNum">     115</span>              :    *  - size_type       _M_element_count</span>
<span id="L116"><span class="lineNum">     116</span>              :    *</span>
<span id="L117"><span class="lineNum">     117</span>              :    *  with _Bucket being _Hash_node_base* and _Hash_node containing:</span>
<span id="L118"><span class="lineNum">     118</span>              :    *</span>
<span id="L119"><span class="lineNum">     119</span>              :    *  - _Hash_node*   _M_next</span>
<span id="L120"><span class="lineNum">     120</span>              :    *  - Tp            _M_value</span>
<span id="L121"><span class="lineNum">     121</span>              :    *  - size_t        _M_hash_code if cache_hash_code is true</span>
<span id="L122"><span class="lineNum">     122</span>              :    *</span>
<span id="L123"><span class="lineNum">     123</span>              :    *  In terms of Standard containers the hashtable is like the aggregation of:</span>
<span id="L124"><span class="lineNum">     124</span>              :    *</span>
<span id="L125"><span class="lineNum">     125</span>              :    *  - std::forward_list&lt;_Node&gt; containing the elements</span>
<span id="L126"><span class="lineNum">     126</span>              :    *  - std::vector&lt;std::forward_list&lt;_Node&gt;::iterator&gt; representing the buckets</span>
<span id="L127"><span class="lineNum">     127</span>              :    *</span>
<span id="L128"><span class="lineNum">     128</span>              :    *  The non-empty buckets contain the node before the first node in the</span>
<span id="L129"><span class="lineNum">     129</span>              :    *  bucket. This design makes it possible to implement something like a</span>
<span id="L130"><span class="lineNum">     130</span>              :    *  std::forward_list::insert_after on container insertion and</span>
<span id="L131"><span class="lineNum">     131</span>              :    *  std::forward_list::erase_after on container erase</span>
<span id="L132"><span class="lineNum">     132</span>              :    *  calls. _M_before_begin is equivalent to</span>
<span id="L133"><span class="lineNum">     133</span>              :    *  std::forward_list::before_begin. Empty buckets contain</span>
<span id="L134"><span class="lineNum">     134</span>              :    *  nullptr.  Note that one of the non-empty buckets contains</span>
<span id="L135"><span class="lineNum">     135</span>              :    *  &amp;_M_before_begin which is not a dereferenceable node so the</span>
<span id="L136"><span class="lineNum">     136</span>              :    *  node pointer in a bucket shall never be dereferenced, only its</span>
<span id="L137"><span class="lineNum">     137</span>              :    *  next node can be.</span>
<span id="L138"><span class="lineNum">     138</span>              :    *</span>
<span id="L139"><span class="lineNum">     139</span>              :    *  Walking through a bucket's nodes requires a check on the hash code to</span>
<span id="L140"><span class="lineNum">     140</span>              :    *  see if each node is still in the bucket. Such a design assumes a</span>
<span id="L141"><span class="lineNum">     141</span>              :    *  quite efficient hash functor and is one of the reasons it is</span>
<span id="L142"><span class="lineNum">     142</span>              :    *  highly advisable to set __cache_hash_code to true.</span>
<span id="L143"><span class="lineNum">     143</span>              :    *</span>
<span id="L144"><span class="lineNum">     144</span>              :    *  The container iterators are simply built from nodes. This way</span>
<span id="L145"><span class="lineNum">     145</span>              :    *  incrementing the iterator is perfectly efficient independent of</span>
<span id="L146"><span class="lineNum">     146</span>              :    *  how many empty buckets there are in the container.</span>
<span id="L147"><span class="lineNum">     147</span>              :    *</span>
<span id="L148"><span class="lineNum">     148</span>              :    *  On insert we compute the element's hash code and use it to find the</span>
<span id="L149"><span class="lineNum">     149</span>              :    *  bucket index. If the element must be inserted in an empty bucket</span>
<span id="L150"><span class="lineNum">     150</span>              :    *  we add it at the beginning of the singly linked list and make the</span>
<span id="L151"><span class="lineNum">     151</span>              :    *  bucket point to _M_before_begin. The bucket that used to point to</span>
<span id="L152"><span class="lineNum">     152</span>              :    *  _M_before_begin, if any, is updated to point to its new before</span>
<span id="L153"><span class="lineNum">     153</span>              :    *  begin node.</span>
<span id="L154"><span class="lineNum">     154</span>              :    *</span>
<span id="L155"><span class="lineNum">     155</span>              :    *  On erase, the simple iterator design requires using the hash</span>
<span id="L156"><span class="lineNum">     156</span>              :    *  functor to get the index of the bucket to update. For this</span>
<span id="L157"><span class="lineNum">     157</span>              :    *  reason, when __cache_hash_code is set to false the hash functor must</span>
<span id="L158"><span class="lineNum">     158</span>              :    *  not throw and this is enforced by a static assertion.</span>
<span id="L159"><span class="lineNum">     159</span>              :    *</span>
<span id="L160"><span class="lineNum">     160</span>              :    *  Functionality is implemented by decomposition into base classes,</span>
<span id="L161"><span class="lineNum">     161</span>              :    *  where the derived _Hashtable class is used in _Map_base,</span>
<span id="L162"><span class="lineNum">     162</span>              :    *  _Insert, _Rehash_base, and _Equality base classes to access the</span>
<span id="L163"><span class="lineNum">     163</span>              :    *  &quot;this&quot; pointer. _Hashtable_base is used in the base classes as a</span>
<span id="L164"><span class="lineNum">     164</span>              :    *  non-recursive, fully-completed-type so that detailed nested type</span>
<span id="L165"><span class="lineNum">     165</span>              :    *  information, such as iterator type and node type, can be</span>
<span id="L166"><span class="lineNum">     166</span>              :    *  used. This is similar to the &quot;Curiously Recurring Template</span>
<span id="L167"><span class="lineNum">     167</span>              :    *  Pattern&quot; (CRTP) technique, but uses a reconstructed, not</span>
<span id="L168"><span class="lineNum">     168</span>              :    *  explicitly passed, template pattern.</span>
<span id="L169"><span class="lineNum">     169</span>              :    *</span>
<span id="L170"><span class="lineNum">     170</span>              :    *  Base class templates are: </span>
<span id="L171"><span class="lineNum">     171</span>              :    *    - __detail::_Hashtable_base</span>
<span id="L172"><span class="lineNum">     172</span>              :    *    - __detail::_Map_base</span>
<span id="L173"><span class="lineNum">     173</span>              :    *    - __detail::_Insert</span>
<span id="L174"><span class="lineNum">     174</span>              :    *    - __detail::_Rehash_base</span>
<span id="L175"><span class="lineNum">     175</span>              :    *    - __detail::_Equality</span>
<span id="L176"><span class="lineNum">     176</span>              :    */</span>
<span id="L177"><span class="lineNum">     177</span>              :   template&lt;typename _Key, typename _Value, typename _Alloc,</span>
<span id="L178"><span class="lineNum">     178</span>              :            typename _ExtractKey, typename _Equal,</span>
<span id="L179"><span class="lineNum">     179</span>              :            typename _Hash, typename _RangeHash, typename _Unused,</span>
<span id="L180"><span class="lineNum">     180</span>              :            typename _RehashPolicy, typename _Traits&gt;</span>
<span id="L181"><span class="lineNum">     181</span>              :     class _Hashtable</span>
<span id="L182"><span class="lineNum">     182</span>              :     : public __detail::_Hashtable_base&lt;_Key, _Value, _ExtractKey, _Equal,</span>
<span id="L183"><span class="lineNum">     183</span>              :                                        _Hash, _RangeHash, _Unused, _Traits&gt;,</span>
<span id="L184"><span class="lineNum">     184</span>              :       public __detail::_Map_base&lt;_Key, _Value, _Alloc, _ExtractKey, _Equal,</span>
<span id="L185"><span class="lineNum">     185</span>              :                                  _Hash, _RangeHash, _Unused,</span>
<span id="L186"><span class="lineNum">     186</span>              :                                  _RehashPolicy, _Traits&gt;,</span>
<span id="L187"><span class="lineNum">     187</span>              :       public __detail::_Insert&lt;_Key, _Value, _Alloc, _ExtractKey, _Equal,</span>
<span id="L188"><span class="lineNum">     188</span>              :                                _Hash, _RangeHash, _Unused,</span>
<span id="L189"><span class="lineNum">     189</span>              :                                _RehashPolicy, _Traits&gt;,</span>
<span id="L190"><span class="lineNum">     190</span>              :       public __detail::_Rehash_base&lt;_Key, _Value, _Alloc, _ExtractKey, _Equal,</span>
<span id="L191"><span class="lineNum">     191</span>              :                                     _Hash, _RangeHash, _Unused,</span>
<span id="L192"><span class="lineNum">     192</span>              :                                     _RehashPolicy, _Traits&gt;,</span>
<span id="L193"><span class="lineNum">     193</span>              :       public __detail::_Equality&lt;_Key, _Value, _Alloc, _ExtractKey, _Equal,</span>
<span id="L194"><span class="lineNum">     194</span>              :                                  _Hash, _RangeHash, _Unused,</span>
<span id="L195"><span class="lineNum">     195</span>              :                                  _RehashPolicy, _Traits&gt;,</span>
<span id="L196"><span class="lineNum">     196</span>              :       private __detail::_Hashtable_alloc&lt;</span>
<span id="L197"><span class="lineNum">     197</span>              :         __alloc_rebind&lt;_Alloc,</span>
<span id="L198"><span class="lineNum">     198</span>              :                        __detail::_Hash_node&lt;_Value,</span>
<span id="L199"><span class="lineNum">     199</span>              :                                             _Traits::__hash_cached::value&gt;&gt;&gt;,</span>
<span id="L200"><span class="lineNum">     200</span>              :       private _Hashtable_enable_default_ctor&lt;_Equal, _Hash, _Alloc&gt;</span>
<span id="L201"><span class="lineNum">     201</span>              :     {</span>
<span id="L202"><span class="lineNum">     202</span>              :       static_assert(is_same&lt;typename remove_cv&lt;_Value&gt;::type, _Value&gt;::value,</span>
<span id="L203"><span class="lineNum">     203</span>              :           &quot;unordered container must have a non-const, non-volatile value_type&quot;);</span>
<span id="L204"><span class="lineNum">     204</span>              : #if __cplusplus &gt; 201703L || defined __STRICT_ANSI__</span>
<span id="L205"><span class="lineNum">     205</span>              :       static_assert(is_same&lt;typename _Alloc::value_type, _Value&gt;{},</span>
<span id="L206"><span class="lineNum">     206</span>              :           &quot;unordered container must have the same value_type as its allocator&quot;);</span>
<span id="L207"><span class="lineNum">     207</span>              : #endif</span>
<span id="L208"><span class="lineNum">     208</span>              : </span>
<span id="L209"><span class="lineNum">     209</span>              :       using __traits_type = _Traits;</span>
<span id="L210"><span class="lineNum">     210</span>              :       using __hash_cached = typename __traits_type::__hash_cached;</span>
<span id="L211"><span class="lineNum">     211</span>              :       using __constant_iterators = typename __traits_type::__constant_iterators;</span>
<span id="L212"><span class="lineNum">     212</span>              :       using __node_type = __detail::_Hash_node&lt;_Value, __hash_cached::value&gt;;</span>
<span id="L213"><span class="lineNum">     213</span>              :       using __node_alloc_type = __alloc_rebind&lt;_Alloc, __node_type&gt;;</span>
<span id="L214"><span class="lineNum">     214</span>              : </span>
<span id="L215"><span class="lineNum">     215</span>              :       using __hashtable_alloc = __detail::_Hashtable_alloc&lt;__node_alloc_type&gt;;</span>
<span id="L216"><span class="lineNum">     216</span>              : </span>
<span id="L217"><span class="lineNum">     217</span>              :       using __node_value_type =</span>
<span id="L218"><span class="lineNum">     218</span>              :         __detail::_Hash_node_value&lt;_Value, __hash_cached::value&gt;;</span>
<span id="L219"><span class="lineNum">     219</span>              :       using __node_ptr = typename __hashtable_alloc::__node_ptr;</span>
<span id="L220"><span class="lineNum">     220</span>              :       using __value_alloc_traits =</span>
<span id="L221"><span class="lineNum">     221</span>              :         typename __hashtable_alloc::__value_alloc_traits;</span>
<span id="L222"><span class="lineNum">     222</span>              :       using __node_alloc_traits =</span>
<span id="L223"><span class="lineNum">     223</span>              :         typename __hashtable_alloc::__node_alloc_traits;</span>
<span id="L224"><span class="lineNum">     224</span>              :       using __node_base = typename __hashtable_alloc::__node_base;</span>
<span id="L225"><span class="lineNum">     225</span>              :       using __node_base_ptr = typename __hashtable_alloc::__node_base_ptr;</span>
<span id="L226"><span class="lineNum">     226</span>              :       using __buckets_ptr = typename __hashtable_alloc::__buckets_ptr;</span>
<span id="L227"><span class="lineNum">     227</span>              : </span>
<span id="L228"><span class="lineNum">     228</span>              :       using __insert_base = __detail::_Insert&lt;_Key, _Value, _Alloc, _ExtractKey,</span>
<span id="L229"><span class="lineNum">     229</span>              :                                               _Equal, _Hash,</span>
<span id="L230"><span class="lineNum">     230</span>              :                                               _RangeHash, _Unused,</span>
<span id="L231"><span class="lineNum">     231</span>              :                                               _RehashPolicy, _Traits&gt;;</span>
<span id="L232"><span class="lineNum">     232</span>              :       using __enable_default_ctor</span>
<span id="L233"><span class="lineNum">     233</span>              :         = _Hashtable_enable_default_ctor&lt;_Equal, _Hash, _Alloc&gt;;</span>
<span id="L234"><span class="lineNum">     234</span>              : </span>
<span id="L235"><span class="lineNum">     235</span>              :     public:</span>
<span id="L236"><span class="lineNum">     236</span>              :       typedef _Key                                              key_type;</span>
<span id="L237"><span class="lineNum">     237</span>              :       typedef _Value                                            value_type;</span>
<span id="L238"><span class="lineNum">     238</span>              :       typedef _Alloc                                            allocator_type;</span>
<span id="L239"><span class="lineNum">     239</span>              :       typedef _Equal                                            key_equal;</span>
<span id="L240"><span class="lineNum">     240</span>              : </span>
<span id="L241"><span class="lineNum">     241</span>              :       // mapped_type, if present, comes from _Map_base.</span>
<span id="L242"><span class="lineNum">     242</span>              :       // hasher, if present, comes from _Hash_code_base/_Hashtable_base.</span>
<span id="L243"><span class="lineNum">     243</span>              :       typedef typename __value_alloc_traits::pointer            pointer;</span>
<span id="L244"><span class="lineNum">     244</span>              :       typedef typename __value_alloc_traits::const_pointer      const_pointer;</span>
<span id="L245"><span class="lineNum">     245</span>              :       typedef value_type&amp;                                   reference;</span>
<span id="L246"><span class="lineNum">     246</span>              :       typedef const value_type&amp;                                     const_reference;</span>
<span id="L247"><span class="lineNum">     247</span>              : </span>
<span id="L248"><span class="lineNum">     248</span>              :       using iterator = typename __insert_base::iterator;</span>
<span id="L249"><span class="lineNum">     249</span>              : </span>
<span id="L250"><span class="lineNum">     250</span>              :       using const_iterator = typename __insert_base::const_iterator;</span>
<span id="L251"><span class="lineNum">     251</span>              : </span>
<span id="L252"><span class="lineNum">     252</span>              :       using local_iterator = __detail::_Local_iterator&lt;key_type, _Value,</span>
<span id="L253"><span class="lineNum">     253</span>              :                         _ExtractKey, _Hash, _RangeHash, _Unused,</span>
<span id="L254"><span class="lineNum">     254</span>              :                                              __constant_iterators::value,</span>
<span id="L255"><span class="lineNum">     255</span>              :                                              __hash_cached::value&gt;;</span>
<span id="L256"><span class="lineNum">     256</span>              : </span>
<span id="L257"><span class="lineNum">     257</span>              :       using const_local_iterator = __detail::_Local_const_iterator&lt;</span>
<span id="L258"><span class="lineNum">     258</span>              :                         key_type, _Value,</span>
<span id="L259"><span class="lineNum">     259</span>              :                         _ExtractKey, _Hash, _RangeHash, _Unused,</span>
<span id="L260"><span class="lineNum">     260</span>              :                         __constant_iterators::value, __hash_cached::value&gt;;</span>
<span id="L261"><span class="lineNum">     261</span>              : </span>
<span id="L262"><span class="lineNum">     262</span>              :     private:</span>
<span id="L263"><span class="lineNum">     263</span>              :       using __rehash_type = _RehashPolicy;</span>
<span id="L264"><span class="lineNum">     264</span>              :       using __rehash_state = typename __rehash_type::_State;</span>
<span id="L265"><span class="lineNum">     265</span>              : </span>
<span id="L266"><span class="lineNum">     266</span>              :       using __unique_keys = typename __traits_type::__unique_keys;</span>
<span id="L267"><span class="lineNum">     267</span>              : </span>
<span id="L268"><span class="lineNum">     268</span>              :       using __hashtable_base = __detail::</span>
<span id="L269"><span class="lineNum">     269</span>              :         _Hashtable_base&lt;_Key, _Value, _ExtractKey,</span>
<span id="L270"><span class="lineNum">     270</span>              :                         _Equal, _Hash, _RangeHash, _Unused, _Traits&gt;;</span>
<span id="L271"><span class="lineNum">     271</span>              : </span>
<span id="L272"><span class="lineNum">     272</span>              :       using __hash_code_base =  typename __hashtable_base::__hash_code_base;</span>
<span id="L273"><span class="lineNum">     273</span>              :       using __hash_code =  typename __hashtable_base::__hash_code;</span>
<span id="L274"><span class="lineNum">     274</span>              :       using __ireturn_type = typename __insert_base::__ireturn_type;</span>
<span id="L275"><span class="lineNum">     275</span>              : </span>
<span id="L276"><span class="lineNum">     276</span>              :       using __map_base = __detail::_Map_base&lt;_Key, _Value, _Alloc, _ExtractKey,</span>
<span id="L277"><span class="lineNum">     277</span>              :                                              _Equal, _Hash, _RangeHash, _Unused,</span>
<span id="L278"><span class="lineNum">     278</span>              :                                              _RehashPolicy, _Traits&gt;;</span>
<span id="L279"><span class="lineNum">     279</span>              : </span>
<span id="L280"><span class="lineNum">     280</span>              :       using __rehash_base = __detail::_Rehash_base&lt;_Key, _Value, _Alloc,</span>
<span id="L281"><span class="lineNum">     281</span>              :                                                    _ExtractKey, _Equal,</span>
<span id="L282"><span class="lineNum">     282</span>              :                                                    _Hash, _RangeHash, _Unused,</span>
<span id="L283"><span class="lineNum">     283</span>              :                                                    _RehashPolicy, _Traits&gt;;</span>
<span id="L284"><span class="lineNum">     284</span>              : </span>
<span id="L285"><span class="lineNum">     285</span>              :       using __eq_base = __detail::_Equality&lt;_Key, _Value, _Alloc, _ExtractKey,</span>
<span id="L286"><span class="lineNum">     286</span>              :                                             _Equal, _Hash, _RangeHash, _Unused,</span>
<span id="L287"><span class="lineNum">     287</span>              :                                             _RehashPolicy, _Traits&gt;;</span>
<span id="L288"><span class="lineNum">     288</span>              : </span>
<span id="L289"><span class="lineNum">     289</span>              :       using __reuse_or_alloc_node_gen_t =</span>
<span id="L290"><span class="lineNum">     290</span>              :         __detail::_ReuseOrAllocNode&lt;__node_alloc_type&gt;;</span>
<span id="L291"><span class="lineNum">     291</span>              :       using __alloc_node_gen_t =</span>
<span id="L292"><span class="lineNum">     292</span>              :         __detail::_AllocNode&lt;__node_alloc_type&gt;;</span>
<span id="L293"><span class="lineNum">     293</span>              :       using __node_builder_t =</span>
<span id="L294"><span class="lineNum">     294</span>              :         __detail::_NodeBuilder&lt;_ExtractKey&gt;;</span>
<span id="L295"><span class="lineNum">     295</span>              : </span>
<span id="L296"><span class="lineNum">     296</span>              :       // Simple RAII type for managing a node containing an element</span>
<span id="L297"><span class="lineNum">     297</span>              :       struct _Scoped_node</span>
<span id="L298"><span class="lineNum">     298</span>              :       {</span>
<span id="L299"><span class="lineNum">     299</span>              :         // Take ownership of a node with a constructed element.</span>
<span id="L300"><span class="lineNum">     300</span>              :         _Scoped_node(__node_ptr __n, __hashtable_alloc* __h)</span>
<span id="L301"><span class="lineNum">     301</span>              :         : _M_h(__h), _M_node(__n) { }</span>
<span id="L302"><span class="lineNum">     302</span>              : </span>
<span id="L303"><span class="lineNum">     303</span>              :         // Allocate a node and construct an element within it.</span>
<span id="L304"><span class="lineNum">     304</span>              :         template&lt;typename... _Args&gt;</span>
<span id="L305"><span class="lineNum">     305</span> <span class="tlaGNC tlaBgGNC">           2 :           _Scoped_node(__hashtable_alloc* __h, _Args&amp;&amp;... __args)</span></span>
<span id="L306"><span class="lineNum">     306</span> <span class="tlaGNC">           2 :           : _M_h(__h),</span></span>
<span id="L307"><span class="lineNum">     307</span> <span class="tlaGNC">           2 :             _M_node(__h-&gt;_M_allocate_node(std::forward&lt;_Args&gt;(__args)...))</span></span>
<span id="L308"><span class="lineNum">     308</span> <span class="tlaGNC">           2 :           { }</span></span>
<span id="L309"><span class="lineNum">     309</span>              : </span>
<span id="L310"><span class="lineNum">     310</span>              :         // Destroy element and deallocate node.</span>
<span id="L311"><span class="lineNum">     311</span> <span class="tlaGNC">           2 :         ~_Scoped_node() { if (_M_node) _M_h-&gt;_M_deallocate_node(_M_node); };</span></span>
<span id="L312"><span class="lineNum">     312</span>              : </span>
<span id="L313"><span class="lineNum">     313</span>              :         _Scoped_node(const _Scoped_node&amp;) = delete;</span>
<span id="L314"><span class="lineNum">     314</span>              :         _Scoped_node&amp; operator=(const _Scoped_node&amp;) = delete;</span>
<span id="L315"><span class="lineNum">     315</span>              : </span>
<span id="L316"><span class="lineNum">     316</span>              :         __hashtable_alloc* _M_h;</span>
<span id="L317"><span class="lineNum">     317</span>              :         __node_ptr _M_node;</span>
<span id="L318"><span class="lineNum">     318</span>              :       };</span>
<span id="L319"><span class="lineNum">     319</span>              : </span>
<span id="L320"><span class="lineNum">     320</span>              :       template&lt;typename _Ht&gt;</span>
<span id="L321"><span class="lineNum">     321</span>              :         static constexpr</span>
<span id="L322"><span class="lineNum">     322</span>              :         __conditional_t&lt;std::is_lvalue_reference&lt;_Ht&gt;::value,</span>
<span id="L323"><span class="lineNum">     323</span>              :                         const value_type&amp;, value_type&amp;&amp;&gt;</span>
<span id="L324"><span class="lineNum">     324</span>              :         __fwd_value_for(value_type&amp; __val) noexcept</span>
<span id="L325"><span class="lineNum">     325</span>              :         { return std::move(__val); }</span>
<span id="L326"><span class="lineNum">     326</span>              : </span>
<span id="L327"><span class="lineNum">     327</span>              :       // Compile-time diagnostics.</span>
<span id="L328"><span class="lineNum">     328</span>              : </span>
<span id="L329"><span class="lineNum">     329</span>              :       // _Hash_code_base has everything protected, so use this derived type to</span>
<span id="L330"><span class="lineNum">     330</span>              :       // access it.</span>
<span id="L331"><span class="lineNum">     331</span>              :       struct __hash_code_base_access : __hash_code_base</span>
<span id="L332"><span class="lineNum">     332</span>              :       { using __hash_code_base::_M_bucket_index; };</span>
<span id="L333"><span class="lineNum">     333</span>              : </span>
<span id="L334"><span class="lineNum">     334</span>              :       // To get bucket index we need _RangeHash not to throw.</span>
<span id="L335"><span class="lineNum">     335</span>              :       static_assert(is_nothrow_default_constructible&lt;_RangeHash&gt;::value,</span>
<span id="L336"><span class="lineNum">     336</span>              :                     &quot;Functor used to map hash code to bucket index&quot;</span>
<span id="L337"><span class="lineNum">     337</span>              :                     &quot; must be nothrow default constructible&quot;);</span>
<span id="L338"><span class="lineNum">     338</span>              :       static_assert(noexcept(</span>
<span id="L339"><span class="lineNum">     339</span>              :         std::declval&lt;const _RangeHash&amp;&gt;()((std::size_t)0, (std::size_t)0)),</span>
<span id="L340"><span class="lineNum">     340</span>              :                     &quot;Functor used to map hash code to bucket index must be&quot;</span>
<span id="L341"><span class="lineNum">     341</span>              :                     &quot; noexcept&quot;);</span>
<span id="L342"><span class="lineNum">     342</span>              : </span>
<span id="L343"><span class="lineNum">     343</span>              :       // To compute bucket index we also need _ExtratKey not to throw.</span>
<span id="L344"><span class="lineNum">     344</span>              :       static_assert(is_nothrow_default_constructible&lt;_ExtractKey&gt;::value,</span>
<span id="L345"><span class="lineNum">     345</span>              :                     &quot;_ExtractKey must be nothrow default constructible&quot;);</span>
<span id="L346"><span class="lineNum">     346</span>              :       static_assert(noexcept(</span>
<span id="L347"><span class="lineNum">     347</span>              :         std::declval&lt;const _ExtractKey&amp;&gt;()(std::declval&lt;_Value&gt;())),</span>
<span id="L348"><span class="lineNum">     348</span>              :                     &quot;_ExtractKey functor must be noexcept invocable&quot;);</span>
<span id="L349"><span class="lineNum">     349</span>              : </span>
<span id="L350"><span class="lineNum">     350</span>              :       template&lt;typename _Keya, typename _Valuea, typename _Alloca,</span>
<span id="L351"><span class="lineNum">     351</span>              :                typename _ExtractKeya, typename _Equala,</span>
<span id="L352"><span class="lineNum">     352</span>              :                typename _Hasha, typename _RangeHasha, typename _Unuseda,</span>
<span id="L353"><span class="lineNum">     353</span>              :                typename _RehashPolicya, typename _Traitsa,</span>
<span id="L354"><span class="lineNum">     354</span>              :                bool _Unique_keysa&gt;</span>
<span id="L355"><span class="lineNum">     355</span>              :         friend struct __detail::_Map_base;</span>
<span id="L356"><span class="lineNum">     356</span>              : </span>
<span id="L357"><span class="lineNum">     357</span>              :       template&lt;typename _Keya, typename _Valuea, typename _Alloca,</span>
<span id="L358"><span class="lineNum">     358</span>              :                typename _ExtractKeya, typename _Equala,</span>
<span id="L359"><span class="lineNum">     359</span>              :                typename _Hasha, typename _RangeHasha, typename _Unuseda,</span>
<span id="L360"><span class="lineNum">     360</span>              :                typename _RehashPolicya, typename _Traitsa&gt;</span>
<span id="L361"><span class="lineNum">     361</span>              :         friend struct __detail::_Insert_base;</span>
<span id="L362"><span class="lineNum">     362</span>              : </span>
<span id="L363"><span class="lineNum">     363</span>              :       template&lt;typename _Keya, typename _Valuea, typename _Alloca,</span>
<span id="L364"><span class="lineNum">     364</span>              :                typename _ExtractKeya, typename _Equala,</span>
<span id="L365"><span class="lineNum">     365</span>              :                typename _Hasha, typename _RangeHasha, typename _Unuseda,</span>
<span id="L366"><span class="lineNum">     366</span>              :                typename _RehashPolicya, typename _Traitsa,</span>
<span id="L367"><span class="lineNum">     367</span>              :                bool _Constant_iteratorsa&gt;</span>
<span id="L368"><span class="lineNum">     368</span>              :         friend struct __detail::_Insert;</span>
<span id="L369"><span class="lineNum">     369</span>              : </span>
<span id="L370"><span class="lineNum">     370</span>              :       template&lt;typename _Keya, typename _Valuea, typename _Alloca,</span>
<span id="L371"><span class="lineNum">     371</span>              :                typename _ExtractKeya, typename _Equala,</span>
<span id="L372"><span class="lineNum">     372</span>              :                typename _Hasha, typename _RangeHasha, typename _Unuseda,</span>
<span id="L373"><span class="lineNum">     373</span>              :                typename _RehashPolicya, typename _Traitsa,</span>
<span id="L374"><span class="lineNum">     374</span>              :                bool _Unique_keysa&gt;</span>
<span id="L375"><span class="lineNum">     375</span>              :         friend struct __detail::_Equality;</span>
<span id="L376"><span class="lineNum">     376</span>              : </span>
<span id="L377"><span class="lineNum">     377</span>              :     public:</span>
<span id="L378"><span class="lineNum">     378</span>              :       using size_type = typename __hashtable_base::size_type;</span>
<span id="L379"><span class="lineNum">     379</span>              :       using difference_type = typename __hashtable_base::difference_type;</span>
<span id="L380"><span class="lineNum">     380</span>              : </span>
<span id="L381"><span class="lineNum">     381</span>              : #if __cplusplus &gt; 201402L</span>
<span id="L382"><span class="lineNum">     382</span>              :       using node_type = _Node_handle&lt;_Key, _Value, __node_alloc_type&gt;;</span>
<span id="L383"><span class="lineNum">     383</span>              :       using insert_return_type = _Node_insert_return&lt;iterator, node_type&gt;;</span>
<span id="L384"><span class="lineNum">     384</span>              : #endif</span>
<span id="L385"><span class="lineNum">     385</span>              : </span>
<span id="L386"><span class="lineNum">     386</span>              :     private:</span>
<span id="L387"><span class="lineNum">     387</span>              :       __buckets_ptr             _M_buckets              = &amp;_M_single_bucket;</span>
<span id="L388"><span class="lineNum">     388</span>              :       size_type                 _M_bucket_count         = 1;</span>
<span id="L389"><span class="lineNum">     389</span>              :       __node_base               _M_before_begin;</span>
<span id="L390"><span class="lineNum">     390</span>              :       size_type                 _M_element_count        = 0;</span>
<span id="L391"><span class="lineNum">     391</span>              :       _RehashPolicy             _M_rehash_policy;</span>
<span id="L392"><span class="lineNum">     392</span>              : </span>
<span id="L393"><span class="lineNum">     393</span>              :       // A single bucket used when only need for 1 bucket. Especially</span>
<span id="L394"><span class="lineNum">     394</span>              :       // interesting in move semantic to leave hashtable with only 1 bucket</span>
<span id="L395"><span class="lineNum">     395</span>              :       // which is not allocated so that we can have those operations noexcept</span>
<span id="L396"><span class="lineNum">     396</span>              :       // qualified.</span>
<span id="L397"><span class="lineNum">     397</span>              :       // Note that we can't leave hashtable with 0 bucket without adding</span>
<span id="L398"><span class="lineNum">     398</span>              :       // numerous checks in the code to avoid 0 modulus.</span>
<span id="L399"><span class="lineNum">     399</span>              :       __node_base_ptr           _M_single_bucket        = nullptr;</span>
<span id="L400"><span class="lineNum">     400</span>              : </span>
<span id="L401"><span class="lineNum">     401</span>              :       void</span>
<span id="L402"><span class="lineNum">     402</span>              :       _M_update_bbegin()</span>
<span id="L403"><span class="lineNum">     403</span>              :       {</span>
<span id="L404"><span class="lineNum">     404</span>              :         if (_M_begin())</span>
<span id="L405"><span class="lineNum">     405</span>              :           _M_buckets[_M_bucket_index(*_M_begin())] = &amp;_M_before_begin;</span>
<span id="L406"><span class="lineNum">     406</span>              :       }</span>
<span id="L407"><span class="lineNum">     407</span>              : </span>
<span id="L408"><span class="lineNum">     408</span>              :       void</span>
<span id="L409"><span class="lineNum">     409</span>              :       _M_update_bbegin(__node_ptr __n)</span>
<span id="L410"><span class="lineNum">     410</span>              :       {</span>
<span id="L411"><span class="lineNum">     411</span>              :         _M_before_begin._M_nxt = __n;</span>
<span id="L412"><span class="lineNum">     412</span>              :         _M_update_bbegin();</span>
<span id="L413"><span class="lineNum">     413</span>              :       }</span>
<span id="L414"><span class="lineNum">     414</span>              : </span>
<span id="L415"><span class="lineNum">     415</span>              :       bool</span>
<span id="L416"><span class="lineNum">     416</span> <span class="tlaGNC">           4 :       _M_uses_single_bucket(__buckets_ptr __bkts) const</span></span>
<span id="L417"><span class="lineNum">     417</span> <span class="tlaGNC">           4 :       { return __builtin_expect(__bkts == &amp;_M_single_bucket, false); }</span></span>
<span id="L418"><span class="lineNum">     418</span>              : </span>
<span id="L419"><span class="lineNum">     419</span>              :       bool</span>
<span id="L420"><span class="lineNum">     420</span>              :       _M_uses_single_bucket() const</span>
<span id="L421"><span class="lineNum">     421</span>              :       { return _M_uses_single_bucket(_M_buckets); }</span>
<span id="L422"><span class="lineNum">     422</span>              : </span>
<span id="L423"><span class="lineNum">     423</span>              :       static constexpr size_t</span>
<span id="L424"><span class="lineNum">     424</span> <span class="tlaGNC">           7 :       __small_size_threshold() noexcept</span></span>
<span id="L425"><span class="lineNum">     425</span>              :       {</span>
<span id="L426"><span class="lineNum">     426</span>              :         return</span>
<span id="L427"><span class="lineNum">     427</span> <span class="tlaGNC">           7 :           __detail::_Hashtable_hash_traits&lt;_Hash&gt;::__small_size_threshold();</span></span>
<span id="L428"><span class="lineNum">     428</span>              :       }</span>
<span id="L429"><span class="lineNum">     429</span>              : </span>
<span id="L430"><span class="lineNum">     430</span>              :       __hashtable_alloc&amp;</span>
<span id="L431"><span class="lineNum">     431</span>              :       _M_base_alloc() { return *this; }</span>
<span id="L432"><span class="lineNum">     432</span>              : </span>
<span id="L433"><span class="lineNum">     433</span>              :       __buckets_ptr</span>
<span id="L434"><span class="lineNum">     434</span> <span class="tlaGNC">           2 :       _M_allocate_buckets(size_type __bkt_count)</span></span>
<span id="L435"><span class="lineNum">     435</span>              :       {</span>
<span id="L436"><span class="lineNum">     436</span> <span class="tlaGNC">           2 :         if (__builtin_expect(__bkt_count == 1, false))</span></span>
<span id="L437"><span class="lineNum">     437</span>              :           {</span>
<span id="L438"><span class="lineNum">     438</span> <span class="tlaUNC tlaBgUNC">           0 :             _M_single_bucket = nullptr;</span></span>
<span id="L439"><span class="lineNum">     439</span> <span class="tlaUNC">           0 :             return &amp;_M_single_bucket;</span></span>
<span id="L440"><span class="lineNum">     440</span>              :           }</span>
<span id="L441"><span class="lineNum">     441</span>              : </span>
<span id="L442"><span class="lineNum">     442</span> <span class="tlaGNC tlaBgGNC">           2 :         return __hashtable_alloc::_M_allocate_buckets(__bkt_count);</span></span>
<span id="L443"><span class="lineNum">     443</span>              :       }</span>
<span id="L444"><span class="lineNum">     444</span>              : </span>
<span id="L445"><span class="lineNum">     445</span>              :       void</span>
<span id="L446"><span class="lineNum">     446</span> <span class="tlaGNC">           4 :       _M_deallocate_buckets(__buckets_ptr __bkts, size_type __bkt_count)</span></span>
<span id="L447"><span class="lineNum">     447</span>              :       {</span>
<span id="L448"><span class="lineNum">     448</span> <span class="tlaGNC">           4 :         if (_M_uses_single_bucket(__bkts))</span></span>
<span id="L449"><span class="lineNum">     449</span> <span class="tlaGNC">           2 :           return;</span></span>
<span id="L450"><span class="lineNum">     450</span>              : </span>
<span id="L451"><span class="lineNum">     451</span> <span class="tlaGNC">           2 :         __hashtable_alloc::_M_deallocate_buckets(__bkts, __bkt_count);</span></span>
<span id="L452"><span class="lineNum">     452</span>              :       }</span>
<span id="L453"><span class="lineNum">     453</span>              : </span>
<span id="L454"><span class="lineNum">     454</span>              :       void</span>
<span id="L455"><span class="lineNum">     455</span> <span class="tlaGNC">           4 :       _M_deallocate_buckets()</span></span>
<span id="L456"><span class="lineNum">     456</span> <span class="tlaGNC">           4 :       { _M_deallocate_buckets(_M_buckets, _M_bucket_count); }</span></span>
<span id="L457"><span class="lineNum">     457</span>              : </span>
<span id="L458"><span class="lineNum">     458</span>              :       // Gets bucket begin, deals with the fact that non-empty buckets contain</span>
<span id="L459"><span class="lineNum">     459</span>              :       // their before begin node.</span>
<span id="L460"><span class="lineNum">     460</span>              :       __node_ptr</span>
<span id="L461"><span class="lineNum">     461</span>              :       _M_bucket_begin(size_type __bkt) const;</span>
<span id="L462"><span class="lineNum">     462</span>              : </span>
<span id="L463"><span class="lineNum">     463</span>              :       __node_ptr</span>
<span id="L464"><span class="lineNum">     464</span> <span class="tlaGNC">          11 :       _M_begin() const</span></span>
<span id="L465"><span class="lineNum">     465</span> <span class="tlaGNC">          11 :       { return static_cast&lt;__node_ptr&gt;(_M_before_begin._M_nxt); }</span></span>
<span id="L466"><span class="lineNum">     466</span>              : </span>
<span id="L467"><span class="lineNum">     467</span>              :       // Assign *this using another _Hashtable instance. Whether elements</span>
<span id="L468"><span class="lineNum">     468</span>              :       // are copied or moved depends on the _Ht reference.</span>
<span id="L469"><span class="lineNum">     469</span>              :       template&lt;typename _Ht&gt;</span>
<span id="L470"><span class="lineNum">     470</span>              :         void</span>
<span id="L471"><span class="lineNum">     471</span>              :         _M_assign_elements(_Ht&amp;&amp;);</span>
<span id="L472"><span class="lineNum">     472</span>              : </span>
<span id="L473"><span class="lineNum">     473</span>              :       template&lt;typename _Ht, typename _NodeGenerator&gt;</span>
<span id="L474"><span class="lineNum">     474</span>              :         void</span>
<span id="L475"><span class="lineNum">     475</span>              :         _M_assign(_Ht&amp;&amp;, const _NodeGenerator&amp;);</span>
<span id="L476"><span class="lineNum">     476</span>              : </span>
<span id="L477"><span class="lineNum">     477</span>              :       void</span>
<span id="L478"><span class="lineNum">     478</span>              :       _M_move_assign(_Hashtable&amp;&amp;, true_type);</span>
<span id="L479"><span class="lineNum">     479</span>              : </span>
<span id="L480"><span class="lineNum">     480</span>              :       void</span>
<span id="L481"><span class="lineNum">     481</span>              :       _M_move_assign(_Hashtable&amp;&amp;, false_type);</span>
<span id="L482"><span class="lineNum">     482</span>              : </span>
<span id="L483"><span class="lineNum">     483</span>              :       void</span>
<span id="L484"><span class="lineNum">     484</span>              :       _M_reset() noexcept;</span>
<span id="L485"><span class="lineNum">     485</span>              : </span>
<span id="L486"><span class="lineNum">     486</span>              :       _Hashtable(const _Hash&amp; __h, const _Equal&amp; __eq,</span>
<span id="L487"><span class="lineNum">     487</span>              :                  const allocator_type&amp; __a)</span>
<span id="L488"><span class="lineNum">     488</span>              :       : __hashtable_base(__h, __eq),</span>
<span id="L489"><span class="lineNum">     489</span>              :         __hashtable_alloc(__node_alloc_type(__a)),</span>
<span id="L490"><span class="lineNum">     490</span>              :         __enable_default_ctor(_Enable_default_constructor_tag{})</span>
<span id="L491"><span class="lineNum">     491</span>              :       { }</span>
<span id="L492"><span class="lineNum">     492</span>              : </span>
<span id="L493"><span class="lineNum">     493</span>              :       template&lt;bool _No_realloc = true&gt;</span>
<span id="L494"><span class="lineNum">     494</span>              :         static constexpr bool</span>
<span id="L495"><span class="lineNum">     495</span>              :         _S_nothrow_move()</span>
<span id="L496"><span class="lineNum">     496</span>              :         {</span>
<span id="L497"><span class="lineNum">     497</span>              : #if __cplusplus &lt;= 201402L</span>
<span id="L498"><span class="lineNum">     498</span>              :           return __and_&lt;__bool_constant&lt;_No_realloc&gt;,</span>
<span id="L499"><span class="lineNum">     499</span>              :                         is_nothrow_copy_constructible&lt;_Hash&gt;,</span>
<span id="L500"><span class="lineNum">     500</span>              :                         is_nothrow_copy_constructible&lt;_Equal&gt;&gt;::value;</span>
<span id="L501"><span class="lineNum">     501</span>              : #else</span>
<span id="L502"><span class="lineNum">     502</span>              :           if constexpr (_No_realloc)</span>
<span id="L503"><span class="lineNum">     503</span>              :             if constexpr (is_nothrow_copy_constructible&lt;_Hash&gt;())</span>
<span id="L504"><span class="lineNum">     504</span>              :               return is_nothrow_copy_constructible&lt;_Equal&gt;();</span>
<span id="L505"><span class="lineNum">     505</span>              :           return false;</span>
<span id="L506"><span class="lineNum">     506</span>              : #endif</span>
<span id="L507"><span class="lineNum">     507</span>              :         }</span>
<span id="L508"><span class="lineNum">     508</span>              : </span>
<span id="L509"><span class="lineNum">     509</span>              :       _Hashtable(_Hashtable&amp;&amp; __ht, __node_alloc_type&amp;&amp; __a,</span>
<span id="L510"><span class="lineNum">     510</span>              :                  true_type /* alloc always equal */)</span>
<span id="L511"><span class="lineNum">     511</span>              :         noexcept(_S_nothrow_move());</span>
<span id="L512"><span class="lineNum">     512</span>              : </span>
<span id="L513"><span class="lineNum">     513</span>              :       _Hashtable(_Hashtable&amp;&amp;, __node_alloc_type&amp;&amp;,</span>
<span id="L514"><span class="lineNum">     514</span>              :                  false_type /* alloc always equal */);</span>
<span id="L515"><span class="lineNum">     515</span>              : </span>
<span id="L516"><span class="lineNum">     516</span>              :       template&lt;typename _InputIterator&gt;</span>
<span id="L517"><span class="lineNum">     517</span>              :         _Hashtable(_InputIterator __first, _InputIterator __last,</span>
<span id="L518"><span class="lineNum">     518</span>              :                    size_type __bkt_count_hint,</span>
<span id="L519"><span class="lineNum">     519</span>              :                    const _Hash&amp;, const _Equal&amp;, const allocator_type&amp;,</span>
<span id="L520"><span class="lineNum">     520</span>              :                    true_type __uks);</span>
<span id="L521"><span class="lineNum">     521</span>              : </span>
<span id="L522"><span class="lineNum">     522</span>              :       template&lt;typename _InputIterator&gt;</span>
<span id="L523"><span class="lineNum">     523</span>              :         _Hashtable(_InputIterator __first, _InputIterator __last,</span>
<span id="L524"><span class="lineNum">     524</span>              :                    size_type __bkt_count_hint,</span>
<span id="L525"><span class="lineNum">     525</span>              :                    const _Hash&amp;, const _Equal&amp;, const allocator_type&amp;,</span>
<span id="L526"><span class="lineNum">     526</span>              :                    false_type __uks);</span>
<span id="L527"><span class="lineNum">     527</span>              : </span>
<span id="L528"><span class="lineNum">     528</span>              :     public:</span>
<span id="L529"><span class="lineNum">     529</span>              :       // Constructor, destructor, assignment, swap</span>
<span id="L530"><span class="lineNum">     530</span> <span class="tlaGNC">           2 :       _Hashtable() = default;</span></span>
<span id="L531"><span class="lineNum">     531</span>              : </span>
<span id="L532"><span class="lineNum">     532</span>              :       _Hashtable(const _Hashtable&amp;);</span>
<span id="L533"><span class="lineNum">     533</span>              : </span>
<span id="L534"><span class="lineNum">     534</span>              :       _Hashtable(const _Hashtable&amp;, const allocator_type&amp;);</span>
<span id="L535"><span class="lineNum">     535</span>              : </span>
<span id="L536"><span class="lineNum">     536</span>              :       explicit</span>
<span id="L537"><span class="lineNum">     537</span>              :       _Hashtable(size_type __bkt_count_hint,</span>
<span id="L538"><span class="lineNum">     538</span>              :                  const _Hash&amp; __hf = _Hash(),</span>
<span id="L539"><span class="lineNum">     539</span>              :                  const key_equal&amp; __eql = key_equal(),</span>
<span id="L540"><span class="lineNum">     540</span>              :                  const allocator_type&amp; __a = allocator_type());</span>
<span id="L541"><span class="lineNum">     541</span>              : </span>
<span id="L542"><span class="lineNum">     542</span>              :       // Use delegating constructors.</span>
<span id="L543"><span class="lineNum">     543</span>              :       _Hashtable(_Hashtable&amp;&amp; __ht)</span>
<span id="L544"><span class="lineNum">     544</span>              :         noexcept(_S_nothrow_move())</span>
<span id="L545"><span class="lineNum">     545</span>              :       : _Hashtable(std::move(__ht), std::move(__ht._M_node_allocator()),</span>
<span id="L546"><span class="lineNum">     546</span>              :                    true_type{})</span>
<span id="L547"><span class="lineNum">     547</span>              :       { }</span>
<span id="L548"><span class="lineNum">     548</span>              : </span>
<span id="L549"><span class="lineNum">     549</span>              :       _Hashtable(_Hashtable&amp;&amp; __ht, const allocator_type&amp; __a)</span>
<span id="L550"><span class="lineNum">     550</span>              :         noexcept(_S_nothrow_move&lt;__node_alloc_traits::_S_always_equal()&gt;())</span>
<span id="L551"><span class="lineNum">     551</span>              :       : _Hashtable(std::move(__ht), __node_alloc_type(__a),</span>
<span id="L552"><span class="lineNum">     552</span>              :                    typename __node_alloc_traits::is_always_equal{})</span>
<span id="L553"><span class="lineNum">     553</span>              :       { }</span>
<span id="L554"><span class="lineNum">     554</span>              : </span>
<span id="L555"><span class="lineNum">     555</span>              :       explicit</span>
<span id="L556"><span class="lineNum">     556</span>              :       _Hashtable(const allocator_type&amp; __a)</span>
<span id="L557"><span class="lineNum">     557</span>              :       : __hashtable_alloc(__node_alloc_type(__a)),</span>
<span id="L558"><span class="lineNum">     558</span>              :         __enable_default_ctor(_Enable_default_constructor_tag{})</span>
<span id="L559"><span class="lineNum">     559</span>              :       { }</span>
<span id="L560"><span class="lineNum">     560</span>              : </span>
<span id="L561"><span class="lineNum">     561</span>              :       template&lt;typename _InputIterator&gt;</span>
<span id="L562"><span class="lineNum">     562</span>              :         _Hashtable(_InputIterator __f, _InputIterator __l,</span>
<span id="L563"><span class="lineNum">     563</span>              :                    size_type __bkt_count_hint = 0,</span>
<span id="L564"><span class="lineNum">     564</span>              :                    const _Hash&amp; __hf = _Hash(),</span>
<span id="L565"><span class="lineNum">     565</span>              :                    const key_equal&amp; __eql = key_equal(),</span>
<span id="L566"><span class="lineNum">     566</span>              :                    const allocator_type&amp; __a = allocator_type())</span>
<span id="L567"><span class="lineNum">     567</span>              :         : _Hashtable(__f, __l, __bkt_count_hint, __hf, __eql, __a,</span>
<span id="L568"><span class="lineNum">     568</span>              :                      __unique_keys{})</span>
<span id="L569"><span class="lineNum">     569</span>              :         { }</span>
<span id="L570"><span class="lineNum">     570</span>              : </span>
<span id="L571"><span class="lineNum">     571</span>              :       _Hashtable(initializer_list&lt;value_type&gt; __l,</span>
<span id="L572"><span class="lineNum">     572</span>              :                  size_type __bkt_count_hint = 0,</span>
<span id="L573"><span class="lineNum">     573</span>              :                  const _Hash&amp; __hf = _Hash(),</span>
<span id="L574"><span class="lineNum">     574</span>              :                  const key_equal&amp; __eql = key_equal(),</span>
<span id="L575"><span class="lineNum">     575</span>              :                  const allocator_type&amp; __a = allocator_type())</span>
<span id="L576"><span class="lineNum">     576</span>              :       : _Hashtable(__l.begin(), __l.end(), __bkt_count_hint,</span>
<span id="L577"><span class="lineNum">     577</span>              :                    __hf, __eql, __a, __unique_keys{})</span>
<span id="L578"><span class="lineNum">     578</span>              :       { }</span>
<span id="L579"><span class="lineNum">     579</span>              : </span>
<span id="L580"><span class="lineNum">     580</span>              :       _Hashtable&amp;</span>
<span id="L581"><span class="lineNum">     581</span>              :       operator=(const _Hashtable&amp; __ht);</span>
<span id="L582"><span class="lineNum">     582</span>              : </span>
<span id="L583"><span class="lineNum">     583</span>              :       _Hashtable&amp;</span>
<span id="L584"><span class="lineNum">     584</span>              :       operator=(_Hashtable&amp;&amp; __ht)</span>
<span id="L585"><span class="lineNum">     585</span>              :       noexcept(__node_alloc_traits::_S_nothrow_move()</span>
<span id="L586"><span class="lineNum">     586</span>              :                &amp;&amp; is_nothrow_move_assignable&lt;_Hash&gt;::value</span>
<span id="L587"><span class="lineNum">     587</span>              :                &amp;&amp; is_nothrow_move_assignable&lt;_Equal&gt;::value)</span>
<span id="L588"><span class="lineNum">     588</span>              :       {</span>
<span id="L589"><span class="lineNum">     589</span>              :         constexpr bool __move_storage =</span>
<span id="L590"><span class="lineNum">     590</span>              :           __node_alloc_traits::_S_propagate_on_move_assign()</span>
<span id="L591"><span class="lineNum">     591</span>              :           || __node_alloc_traits::_S_always_equal();</span>
<span id="L592"><span class="lineNum">     592</span>              :         _M_move_assign(std::move(__ht), __bool_constant&lt;__move_storage&gt;());</span>
<span id="L593"><span class="lineNum">     593</span>              :         return *this;</span>
<span id="L594"><span class="lineNum">     594</span>              :       }</span>
<span id="L595"><span class="lineNum">     595</span>              : </span>
<span id="L596"><span class="lineNum">     596</span>              :       _Hashtable&amp;</span>
<span id="L597"><span class="lineNum">     597</span>              :       operator=(initializer_list&lt;value_type&gt; __l)</span>
<span id="L598"><span class="lineNum">     598</span>              :       {</span>
<span id="L599"><span class="lineNum">     599</span>              :         __reuse_or_alloc_node_gen_t __roan(_M_begin(), *this);</span>
<span id="L600"><span class="lineNum">     600</span>              :         _M_before_begin._M_nxt = nullptr;</span>
<span id="L601"><span class="lineNum">     601</span>              :         clear();</span>
<span id="L602"><span class="lineNum">     602</span>              : </span>
<span id="L603"><span class="lineNum">     603</span>              :         // We consider that all elements of __l are going to be inserted.</span>
<span id="L604"><span class="lineNum">     604</span>              :         auto __l_bkt_count = _M_rehash_policy._M_bkt_for_elements(__l.size());</span>
<span id="L605"><span class="lineNum">     605</span>              : </span>
<span id="L606"><span class="lineNum">     606</span>              :         // Do not shrink to keep potential user reservation.</span>
<span id="L607"><span class="lineNum">     607</span>              :         if (_M_bucket_count &lt; __l_bkt_count)</span>
<span id="L608"><span class="lineNum">     608</span>              :           rehash(__l_bkt_count);</span>
<span id="L609"><span class="lineNum">     609</span>              : </span>
<span id="L610"><span class="lineNum">     610</span>              :         this-&gt;_M_insert_range(__l.begin(), __l.end(), __roan, __unique_keys{});</span>
<span id="L611"><span class="lineNum">     611</span>              :         return *this;</span>
<span id="L612"><span class="lineNum">     612</span>              :       }</span>
<span id="L613"><span class="lineNum">     613</span>              : </span>
<span id="L614"><span class="lineNum">     614</span>              :       ~_Hashtable() noexcept;</span>
<span id="L615"><span class="lineNum">     615</span>              : </span>
<span id="L616"><span class="lineNum">     616</span>              :       void</span>
<span id="L617"><span class="lineNum">     617</span>              :       swap(_Hashtable&amp;)</span>
<span id="L618"><span class="lineNum">     618</span>              :       noexcept(__and_&lt;__is_nothrow_swappable&lt;_Hash&gt;,</span>
<span id="L619"><span class="lineNum">     619</span>              :                       __is_nothrow_swappable&lt;_Equal&gt;&gt;::value);</span>
<span id="L620"><span class="lineNum">     620</span>              : </span>
<span id="L621"><span class="lineNum">     621</span>              :       // Basic container operations</span>
<span id="L622"><span class="lineNum">     622</span>              :       iterator</span>
<span id="L623"><span class="lineNum">     623</span> <span class="tlaGNC">           7 :       begin() noexcept</span></span>
<span id="L624"><span class="lineNum">     624</span> <span class="tlaGNC">           7 :       { return iterator(_M_begin()); }</span></span>
<span id="L625"><span class="lineNum">     625</span>              : </span>
<span id="L626"><span class="lineNum">     626</span>              :       const_iterator</span>
<span id="L627"><span class="lineNum">     627</span> <span class="tlaUNC tlaBgUNC">           0 :       begin() const noexcept</span></span>
<span id="L628"><span class="lineNum">     628</span> <span class="tlaUNC">           0 :       { return const_iterator(_M_begin()); }</span></span>
<span id="L629"><span class="lineNum">     629</span>              : </span>
<span id="L630"><span class="lineNum">     630</span>              :       iterator</span>
<span id="L631"><span class="lineNum">     631</span> <span class="tlaGNC tlaBgGNC">          24 :       end() noexcept</span></span>
<span id="L632"><span class="lineNum">     632</span> <span class="tlaGNC">          24 :       { return iterator(nullptr); }</span></span>
<span id="L633"><span class="lineNum">     633</span>              : </span>
<span id="L634"><span class="lineNum">     634</span>              :       const_iterator</span>
<span id="L635"><span class="lineNum">     635</span> <span class="tlaUNC tlaBgUNC">           0 :       end() const noexcept</span></span>
<span id="L636"><span class="lineNum">     636</span> <span class="tlaUNC">           0 :       { return const_iterator(nullptr); }</span></span>
<span id="L637"><span class="lineNum">     637</span>              : </span>
<span id="L638"><span class="lineNum">     638</span>              :       const_iterator</span>
<span id="L639"><span class="lineNum">     639</span>              :       cbegin() const noexcept</span>
<span id="L640"><span class="lineNum">     640</span>              :       { return const_iterator(_M_begin()); }</span>
<span id="L641"><span class="lineNum">     641</span>              : </span>
<span id="L642"><span class="lineNum">     642</span>              :       const_iterator</span>
<span id="L643"><span class="lineNum">     643</span>              :       cend() const noexcept</span>
<span id="L644"><span class="lineNum">     644</span>              :       { return const_iterator(nullptr); }</span>
<span id="L645"><span class="lineNum">     645</span>              : </span>
<span id="L646"><span class="lineNum">     646</span>              :       size_type</span>
<span id="L647"><span class="lineNum">     647</span> <span class="tlaGNC tlaBgGNC">           7 :       size() const noexcept</span></span>
<span id="L648"><span class="lineNum">     648</span> <span class="tlaGNC">           7 :       { return _M_element_count; }</span></span>
<span id="L649"><span class="lineNum">     649</span>              : </span>
<span id="L650"><span class="lineNum">     650</span>              :       _GLIBCXX_NODISCARD bool</span>
<span id="L651"><span class="lineNum">     651</span>              :       empty() const noexcept</span>
<span id="L652"><span class="lineNum">     652</span>              :       { return size() == 0; }</span>
<span id="L653"><span class="lineNum">     653</span>              : </span>
<span id="L654"><span class="lineNum">     654</span>              :       allocator_type</span>
<span id="L655"><span class="lineNum">     655</span>              :       get_allocator() const noexcept</span>
<span id="L656"><span class="lineNum">     656</span>              :       { return allocator_type(this-&gt;_M_node_allocator()); }</span>
<span id="L657"><span class="lineNum">     657</span>              : </span>
<span id="L658"><span class="lineNum">     658</span>              :       size_type</span>
<span id="L659"><span class="lineNum">     659</span>              :       max_size() const noexcept</span>
<span id="L660"><span class="lineNum">     660</span>              :       { return __node_alloc_traits::max_size(this-&gt;_M_node_allocator()); }</span>
<span id="L661"><span class="lineNum">     661</span>              : </span>
<span id="L662"><span class="lineNum">     662</span>              :       // Observers</span>
<span id="L663"><span class="lineNum">     663</span>              :       key_equal</span>
<span id="L664"><span class="lineNum">     664</span>              :       key_eq() const</span>
<span id="L665"><span class="lineNum">     665</span>              :       { return this-&gt;_M_eq(); }</span>
<span id="L666"><span class="lineNum">     666</span>              : </span>
<span id="L667"><span class="lineNum">     667</span>              :       // hash_function, if present, comes from _Hash_code_base.</span>
<span id="L668"><span class="lineNum">     668</span>              : </span>
<span id="L669"><span class="lineNum">     669</span>              :       // Bucket operations</span>
<span id="L670"><span class="lineNum">     670</span>              :       size_type</span>
<span id="L671"><span class="lineNum">     671</span>              :       bucket_count() const noexcept</span>
<span id="L672"><span class="lineNum">     672</span>              :       { return _M_bucket_count; }</span>
<span id="L673"><span class="lineNum">     673</span>              : </span>
<span id="L674"><span class="lineNum">     674</span>              :       size_type</span>
<span id="L675"><span class="lineNum">     675</span>              :       max_bucket_count() const noexcept</span>
<span id="L676"><span class="lineNum">     676</span>              :       { return max_size(); }</span>
<span id="L677"><span class="lineNum">     677</span>              : </span>
<span id="L678"><span class="lineNum">     678</span>              :       size_type</span>
<span id="L679"><span class="lineNum">     679</span>              :       bucket_size(size_type __bkt) const</span>
<span id="L680"><span class="lineNum">     680</span>              :       { return std::distance(begin(__bkt), end(__bkt)); }</span>
<span id="L681"><span class="lineNum">     681</span>              : </span>
<span id="L682"><span class="lineNum">     682</span>              :       size_type</span>
<span id="L683"><span class="lineNum">     683</span>              :       bucket(const key_type&amp; __k) const</span>
<span id="L684"><span class="lineNum">     684</span>              :       { return _M_bucket_index(this-&gt;_M_hash_code(__k)); }</span>
<span id="L685"><span class="lineNum">     685</span>              : </span>
<span id="L686"><span class="lineNum">     686</span>              :       local_iterator</span>
<span id="L687"><span class="lineNum">     687</span>              :       begin(size_type __bkt)</span>
<span id="L688"><span class="lineNum">     688</span>              :       {</span>
<span id="L689"><span class="lineNum">     689</span>              :         return local_iterator(*this, _M_bucket_begin(__bkt),</span>
<span id="L690"><span class="lineNum">     690</span>              :                               __bkt, _M_bucket_count);</span>
<span id="L691"><span class="lineNum">     691</span>              :       }</span>
<span id="L692"><span class="lineNum">     692</span>              : </span>
<span id="L693"><span class="lineNum">     693</span>              :       local_iterator</span>
<span id="L694"><span class="lineNum">     694</span>              :       end(size_type __bkt)</span>
<span id="L695"><span class="lineNum">     695</span>              :       { return local_iterator(*this, nullptr, __bkt, _M_bucket_count); }</span>
<span id="L696"><span class="lineNum">     696</span>              : </span>
<span id="L697"><span class="lineNum">     697</span>              :       const_local_iterator</span>
<span id="L698"><span class="lineNum">     698</span>              :       begin(size_type __bkt) const</span>
<span id="L699"><span class="lineNum">     699</span>              :       {</span>
<span id="L700"><span class="lineNum">     700</span>              :         return const_local_iterator(*this, _M_bucket_begin(__bkt),</span>
<span id="L701"><span class="lineNum">     701</span>              :                                     __bkt, _M_bucket_count);</span>
<span id="L702"><span class="lineNum">     702</span>              :       }</span>
<span id="L703"><span class="lineNum">     703</span>              : </span>
<span id="L704"><span class="lineNum">     704</span>              :       const_local_iterator</span>
<span id="L705"><span class="lineNum">     705</span>              :       end(size_type __bkt) const</span>
<span id="L706"><span class="lineNum">     706</span>              :       { return const_local_iterator(*this, nullptr, __bkt, _M_bucket_count); }</span>
<span id="L707"><span class="lineNum">     707</span>              : </span>
<span id="L708"><span class="lineNum">     708</span>              :       // DR 691.</span>
<span id="L709"><span class="lineNum">     709</span>              :       const_local_iterator</span>
<span id="L710"><span class="lineNum">     710</span>              :       cbegin(size_type __bkt) const</span>
<span id="L711"><span class="lineNum">     711</span>              :       {</span>
<span id="L712"><span class="lineNum">     712</span>              :         return const_local_iterator(*this, _M_bucket_begin(__bkt),</span>
<span id="L713"><span class="lineNum">     713</span>              :                                     __bkt, _M_bucket_count);</span>
<span id="L714"><span class="lineNum">     714</span>              :       }</span>
<span id="L715"><span class="lineNum">     715</span>              : </span>
<span id="L716"><span class="lineNum">     716</span>              :       const_local_iterator</span>
<span id="L717"><span class="lineNum">     717</span>              :       cend(size_type __bkt) const</span>
<span id="L718"><span class="lineNum">     718</span>              :       { return const_local_iterator(*this, nullptr, __bkt, _M_bucket_count); }</span>
<span id="L719"><span class="lineNum">     719</span>              : </span>
<span id="L720"><span class="lineNum">     720</span>              :       float</span>
<span id="L721"><span class="lineNum">     721</span>              :       load_factor() const noexcept</span>
<span id="L722"><span class="lineNum">     722</span>              :       {</span>
<span id="L723"><span class="lineNum">     723</span>              :         return static_cast&lt;float&gt;(size()) / static_cast&lt;float&gt;(bucket_count());</span>
<span id="L724"><span class="lineNum">     724</span>              :       }</span>
<span id="L725"><span class="lineNum">     725</span>              : </span>
<span id="L726"><span class="lineNum">     726</span>              :       // max_load_factor, if present, comes from _Rehash_base.</span>
<span id="L727"><span class="lineNum">     727</span>              : </span>
<span id="L728"><span class="lineNum">     728</span>              :       // Generalization of max_load_factor.  Extension, not found in</span>
<span id="L729"><span class="lineNum">     729</span>              :       // TR1.  Only useful if _RehashPolicy is something other than</span>
<span id="L730"><span class="lineNum">     730</span>              :       // the default.</span>
<span id="L731"><span class="lineNum">     731</span>              :       const _RehashPolicy&amp;</span>
<span id="L732"><span class="lineNum">     732</span>              :       __rehash_policy() const</span>
<span id="L733"><span class="lineNum">     733</span>              :       { return _M_rehash_policy; }</span>
<span id="L734"><span class="lineNum">     734</span>              : </span>
<span id="L735"><span class="lineNum">     735</span>              :       void</span>
<span id="L736"><span class="lineNum">     736</span>              :       __rehash_policy(const _RehashPolicy&amp; __pol)</span>
<span id="L737"><span class="lineNum">     737</span>              :       { _M_rehash_policy = __pol; }</span>
<span id="L738"><span class="lineNum">     738</span>              : </span>
<span id="L739"><span class="lineNum">     739</span>              :       // Lookup.</span>
<span id="L740"><span class="lineNum">     740</span>              :       iterator</span>
<span id="L741"><span class="lineNum">     741</span>              :       find(const key_type&amp; __k);</span>
<span id="L742"><span class="lineNum">     742</span>              : </span>
<span id="L743"><span class="lineNum">     743</span>              :       const_iterator</span>
<span id="L744"><span class="lineNum">     744</span>              :       find(const key_type&amp; __k) const;</span>
<span id="L745"><span class="lineNum">     745</span>              : </span>
<span id="L746"><span class="lineNum">     746</span>              :       size_type</span>
<span id="L747"><span class="lineNum">     747</span>              :       count(const key_type&amp; __k) const;</span>
<span id="L748"><span class="lineNum">     748</span>              : </span>
<span id="L749"><span class="lineNum">     749</span>              :       std::pair&lt;iterator, iterator&gt;</span>
<span id="L750"><span class="lineNum">     750</span>              :       equal_range(const key_type&amp; __k);</span>
<span id="L751"><span class="lineNum">     751</span>              : </span>
<span id="L752"><span class="lineNum">     752</span>              :       std::pair&lt;const_iterator, const_iterator&gt;</span>
<span id="L753"><span class="lineNum">     753</span>              :       equal_range(const key_type&amp; __k) const;</span>
<span id="L754"><span class="lineNum">     754</span>              : </span>
<span id="L755"><span class="lineNum">     755</span>              : #if __cplusplus &gt;= 202002L</span>
<span id="L756"><span class="lineNum">     756</span>              : #define __cpp_lib_generic_unordered_lookup 201811L</span>
<span id="L757"><span class="lineNum">     757</span>              : </span>
<span id="L758"><span class="lineNum">     758</span>              :       template&lt;typename _Kt,</span>
<span id="L759"><span class="lineNum">     759</span>              :                typename = __has_is_transparent_t&lt;_Hash, _Kt&gt;,</span>
<span id="L760"><span class="lineNum">     760</span>              :                typename = __has_is_transparent_t&lt;_Equal, _Kt&gt;&gt;</span>
<span id="L761"><span class="lineNum">     761</span>              :         iterator</span>
<span id="L762"><span class="lineNum">     762</span>              :         _M_find_tr(const _Kt&amp; __k);</span>
<span id="L763"><span class="lineNum">     763</span>              : </span>
<span id="L764"><span class="lineNum">     764</span>              :       template&lt;typename _Kt,</span>
<span id="L765"><span class="lineNum">     765</span>              :                typename = __has_is_transparent_t&lt;_Hash, _Kt&gt;,</span>
<span id="L766"><span class="lineNum">     766</span>              :                typename = __has_is_transparent_t&lt;_Equal, _Kt&gt;&gt;</span>
<span id="L767"><span class="lineNum">     767</span>              :         const_iterator</span>
<span id="L768"><span class="lineNum">     768</span>              :         _M_find_tr(const _Kt&amp; __k) const;</span>
<span id="L769"><span class="lineNum">     769</span>              : </span>
<span id="L770"><span class="lineNum">     770</span>              :       template&lt;typename _Kt,</span>
<span id="L771"><span class="lineNum">     771</span>              :                typename = __has_is_transparent_t&lt;_Hash, _Kt&gt;,</span>
<span id="L772"><span class="lineNum">     772</span>              :                typename = __has_is_transparent_t&lt;_Equal, _Kt&gt;&gt;</span>
<span id="L773"><span class="lineNum">     773</span>              :         size_type</span>
<span id="L774"><span class="lineNum">     774</span>              :         _M_count_tr(const _Kt&amp; __k) const;</span>
<span id="L775"><span class="lineNum">     775</span>              : </span>
<span id="L776"><span class="lineNum">     776</span>              :       template&lt;typename _Kt,</span>
<span id="L777"><span class="lineNum">     777</span>              :                typename = __has_is_transparent_t&lt;_Hash, _Kt&gt;,</span>
<span id="L778"><span class="lineNum">     778</span>              :                typename = __has_is_transparent_t&lt;_Equal, _Kt&gt;&gt;</span>
<span id="L779"><span class="lineNum">     779</span>              :         pair&lt;iterator, iterator&gt;</span>
<span id="L780"><span class="lineNum">     780</span>              :         _M_equal_range_tr(const _Kt&amp; __k);</span>
<span id="L781"><span class="lineNum">     781</span>              : </span>
<span id="L782"><span class="lineNum">     782</span>              :       template&lt;typename _Kt,</span>
<span id="L783"><span class="lineNum">     783</span>              :                typename = __has_is_transparent_t&lt;_Hash, _Kt&gt;,</span>
<span id="L784"><span class="lineNum">     784</span>              :                typename = __has_is_transparent_t&lt;_Equal, _Kt&gt;&gt;</span>
<span id="L785"><span class="lineNum">     785</span>              :         pair&lt;const_iterator, const_iterator&gt;</span>
<span id="L786"><span class="lineNum">     786</span>              :         _M_equal_range_tr(const _Kt&amp; __k) const;</span>
<span id="L787"><span class="lineNum">     787</span>              : #endif // C++20</span>
<span id="L788"><span class="lineNum">     788</span>              : </span>
<span id="L789"><span class="lineNum">     789</span>              :     private:</span>
<span id="L790"><span class="lineNum">     790</span>              :       // Bucket index computation helpers.</span>
<span id="L791"><span class="lineNum">     791</span>              :       size_type</span>
<span id="L792"><span class="lineNum">     792</span> <span class="tlaUNC tlaBgUNC">           0 :       _M_bucket_index(const __node_value_type&amp; __n) const noexcept</span></span>
<span id="L793"><span class="lineNum">     793</span> <span class="tlaUNC">           0 :       { return __hash_code_base::_M_bucket_index(__n, _M_bucket_count); }</span></span>
<span id="L794"><span class="lineNum">     794</span>              : </span>
<span id="L795"><span class="lineNum">     795</span>              :       size_type</span>
<span id="L796"><span class="lineNum">     796</span> <span class="tlaGNC tlaBgGNC">           4 :       _M_bucket_index(__hash_code __c) const</span></span>
<span id="L797"><span class="lineNum">     797</span> <span class="tlaGNC">           4 :       { return __hash_code_base::_M_bucket_index(__c, _M_bucket_count); }</span></span>
<span id="L798"><span class="lineNum">     798</span>              : </span>
<span id="L799"><span class="lineNum">     799</span>              :       __node_base_ptr</span>
<span id="L800"><span class="lineNum">     800</span>              :       _M_find_before_node(const key_type&amp;);</span>
<span id="L801"><span class="lineNum">     801</span>              : </span>
<span id="L802"><span class="lineNum">     802</span>              :       // Find and insert helper functions and types</span>
<span id="L803"><span class="lineNum">     803</span>              :       // Find the node before the one matching the criteria.</span>
<span id="L804"><span class="lineNum">     804</span>              :       __node_base_ptr</span>
<span id="L805"><span class="lineNum">     805</span>              :       _M_find_before_node(size_type, const key_type&amp;, __hash_code) const;</span>
<span id="L806"><span class="lineNum">     806</span>              : </span>
<span id="L807"><span class="lineNum">     807</span>              :       template&lt;typename _Kt&gt;</span>
<span id="L808"><span class="lineNum">     808</span>              :         __node_base_ptr</span>
<span id="L809"><span class="lineNum">     809</span>              :         _M_find_before_node_tr(size_type, const _Kt&amp;, __hash_code) const;</span>
<span id="L810"><span class="lineNum">     810</span>              : </span>
<span id="L811"><span class="lineNum">     811</span>              :       __node_ptr</span>
<span id="L812"><span class="lineNum">     812</span> <span class="tlaGNC">           2 :       _M_find_node(size_type __bkt, const key_type&amp; __key,</span></span>
<span id="L813"><span class="lineNum">     813</span>              :                    __hash_code __c) const</span>
<span id="L814"><span class="lineNum">     814</span>              :       {</span>
<span id="L815"><span class="lineNum">     815</span> <span class="tlaGNC">           2 :         __node_base_ptr __before_n = _M_find_before_node(__bkt, __key, __c);</span></span>
<span id="L816"><span class="lineNum">     816</span> <span class="tlaGNC">           2 :         if (__before_n)</span></span>
<span id="L817"><span class="lineNum">     817</span> <span class="tlaUNC tlaBgUNC">           0 :           return static_cast&lt;__node_ptr&gt;(__before_n-&gt;_M_nxt);</span></span>
<span id="L818"><span class="lineNum">     818</span> <span class="tlaGNC tlaBgGNC">           2 :         return nullptr;</span></span>
<span id="L819"><span class="lineNum">     819</span>              :       }</span>
<span id="L820"><span class="lineNum">     820</span>              : </span>
<span id="L821"><span class="lineNum">     821</span>              :       template&lt;typename _Kt&gt;</span>
<span id="L822"><span class="lineNum">     822</span>              :         __node_ptr</span>
<span id="L823"><span class="lineNum">     823</span>              :         _M_find_node_tr(size_type __bkt, const _Kt&amp; __key,</span>
<span id="L824"><span class="lineNum">     824</span>              :                         __hash_code __c) const</span>
<span id="L825"><span class="lineNum">     825</span>              :         {</span>
<span id="L826"><span class="lineNum">     826</span>              :           auto __before_n = _M_find_before_node_tr(__bkt, __key, __c);</span>
<span id="L827"><span class="lineNum">     827</span>              :           if (__before_n)</span>
<span id="L828"><span class="lineNum">     828</span>              :             return static_cast&lt;__node_ptr&gt;(__before_n-&gt;_M_nxt);</span>
<span id="L829"><span class="lineNum">     829</span>              :           return nullptr;</span>
<span id="L830"><span class="lineNum">     830</span>              :         }</span>
<span id="L831"><span class="lineNum">     831</span>              : </span>
<span id="L832"><span class="lineNum">     832</span>              :       // Insert a node at the beginning of a bucket.</span>
<span id="L833"><span class="lineNum">     833</span>              :       void</span>
<span id="L834"><span class="lineNum">     834</span>              :       _M_insert_bucket_begin(size_type, __node_ptr);</span>
<span id="L835"><span class="lineNum">     835</span>              : </span>
<span id="L836"><span class="lineNum">     836</span>              :       // Remove the bucket first node</span>
<span id="L837"><span class="lineNum">     837</span>              :       void</span>
<span id="L838"><span class="lineNum">     838</span>              :       _M_remove_bucket_begin(size_type __bkt, __node_ptr __next_n,</span>
<span id="L839"><span class="lineNum">     839</span>              :                              size_type __next_bkt);</span>
<span id="L840"><span class="lineNum">     840</span>              : </span>
<span id="L841"><span class="lineNum">     841</span>              :       // Get the node before __n in the bucket __bkt</span>
<span id="L842"><span class="lineNum">     842</span>              :       __node_base_ptr</span>
<span id="L843"><span class="lineNum">     843</span>              :       _M_get_previous_node(size_type __bkt, __node_ptr __n);</span>
<span id="L844"><span class="lineNum">     844</span>              : </span>
<span id="L845"><span class="lineNum">     845</span>              :       pair&lt;const_iterator, __hash_code&gt;</span>
<span id="L846"><span class="lineNum">     846</span>              :       _M_compute_hash_code(const_iterator __hint, const key_type&amp; __k) const;</span>
<span id="L847"><span class="lineNum">     847</span>              : </span>
<span id="L848"><span class="lineNum">     848</span>              :       // Insert node __n with hash code __code, in bucket __bkt if no</span>
<span id="L849"><span class="lineNum">     849</span>              :       // rehash (assumes no element with same key already present).</span>
<span id="L850"><span class="lineNum">     850</span>              :       // Takes ownership of __n if insertion succeeds, throws otherwise.</span>
<span id="L851"><span class="lineNum">     851</span>              :       iterator</span>
<span id="L852"><span class="lineNum">     852</span>              :       _M_insert_unique_node(size_type __bkt, __hash_code,</span>
<span id="L853"><span class="lineNum">     853</span>              :                             __node_ptr __n, size_type __n_elt = 1);</span>
<span id="L854"><span class="lineNum">     854</span>              : </span>
<span id="L855"><span class="lineNum">     855</span>              :       // Insert node __n with key __k and hash code __code.</span>
<span id="L856"><span class="lineNum">     856</span>              :       // Takes ownership of __n if insertion succeeds, throws otherwise.</span>
<span id="L857"><span class="lineNum">     857</span>              :       iterator</span>
<span id="L858"><span class="lineNum">     858</span>              :       _M_insert_multi_node(__node_ptr __hint,</span>
<span id="L859"><span class="lineNum">     859</span>              :                            __hash_code __code, __node_ptr __n);</span>
<span id="L860"><span class="lineNum">     860</span>              : </span>
<span id="L861"><span class="lineNum">     861</span>              :       template&lt;typename... _Args&gt;</span>
<span id="L862"><span class="lineNum">     862</span>              :         std::pair&lt;iterator, bool&gt;</span>
<span id="L863"><span class="lineNum">     863</span>              :         _M_emplace(true_type __uks, _Args&amp;&amp;... __args);</span>
<span id="L864"><span class="lineNum">     864</span>              : </span>
<span id="L865"><span class="lineNum">     865</span>              :       template&lt;typename... _Args&gt;</span>
<span id="L866"><span class="lineNum">     866</span>              :         iterator</span>
<span id="L867"><span class="lineNum">     867</span>              :         _M_emplace(false_type __uks, _Args&amp;&amp;... __args)</span>
<span id="L868"><span class="lineNum">     868</span>              :         { return _M_emplace(cend(), __uks, std::forward&lt;_Args&gt;(__args)...); }</span>
<span id="L869"><span class="lineNum">     869</span>              : </span>
<span id="L870"><span class="lineNum">     870</span>              :       // Emplace with hint, useless when keys are unique.</span>
<span id="L871"><span class="lineNum">     871</span>              :       template&lt;typename... _Args&gt;</span>
<span id="L872"><span class="lineNum">     872</span>              :         iterator</span>
<span id="L873"><span class="lineNum">     873</span>              :         _M_emplace(const_iterator, true_type __uks, _Args&amp;&amp;... __args)</span>
<span id="L874"><span class="lineNum">     874</span>              :         { return _M_emplace(__uks, std::forward&lt;_Args&gt;(__args)...).first; }</span>
<span id="L875"><span class="lineNum">     875</span>              : </span>
<span id="L876"><span class="lineNum">     876</span>              :       template&lt;typename... _Args&gt;</span>
<span id="L877"><span class="lineNum">     877</span>              :         iterator</span>
<span id="L878"><span class="lineNum">     878</span>              :         _M_emplace(const_iterator, false_type __uks, _Args&amp;&amp;... __args);</span>
<span id="L879"><span class="lineNum">     879</span>              : </span>
<span id="L880"><span class="lineNum">     880</span>              :       template&lt;typename _Kt, typename _Arg, typename _NodeGenerator&gt;</span>
<span id="L881"><span class="lineNum">     881</span>              :         std::pair&lt;iterator, bool&gt;</span>
<span id="L882"><span class="lineNum">     882</span>              :         _M_insert_unique(_Kt&amp;&amp;, _Arg&amp;&amp;, const _NodeGenerator&amp;);</span>
<span id="L883"><span class="lineNum">     883</span>              : </span>
<span id="L884"><span class="lineNum">     884</span>              :       template&lt;typename _Kt&gt;</span>
<span id="L885"><span class="lineNum">     885</span>              :         static __conditional_t&lt;</span>
<span id="L886"><span class="lineNum">     886</span>              :           __and_&lt;__is_nothrow_invocable&lt;_Hash&amp;, const key_type&amp;&gt;,</span>
<span id="L887"><span class="lineNum">     887</span>              :                  __not_&lt;__is_nothrow_invocable&lt;_Hash&amp;, _Kt&gt;&gt;&gt;::value,</span>
<span id="L888"><span class="lineNum">     888</span>              :           key_type, _Kt&amp;&amp;&gt;</span>
<span id="L889"><span class="lineNum">     889</span>              :         _S_forward_key(_Kt&amp;&amp; __k)</span>
<span id="L890"><span class="lineNum">     890</span>              :         { return std::forward&lt;_Kt&gt;(__k); }</span>
<span id="L891"><span class="lineNum">     891</span>              : </span>
<span id="L892"><span class="lineNum">     892</span>              :       static const key_type&amp;</span>
<span id="L893"><span class="lineNum">     893</span>              :       _S_forward_key(const key_type&amp; __k)</span>
<span id="L894"><span class="lineNum">     894</span>              :       { return __k; }</span>
<span id="L895"><span class="lineNum">     895</span>              : </span>
<span id="L896"><span class="lineNum">     896</span>              :       static key_type&amp;&amp;</span>
<span id="L897"><span class="lineNum">     897</span>              :       _S_forward_key(key_type&amp;&amp; __k)</span>
<span id="L898"><span class="lineNum">     898</span>              :       { return std::move(__k); }</span>
<span id="L899"><span class="lineNum">     899</span>              : </span>
<span id="L900"><span class="lineNum">     900</span>              :       template&lt;typename _Arg, typename _NodeGenerator&gt;</span>
<span id="L901"><span class="lineNum">     901</span>              :         std::pair&lt;iterator, bool&gt;</span>
<span id="L902"><span class="lineNum">     902</span>              :         _M_insert_unique_aux(_Arg&amp;&amp; __arg, const _NodeGenerator&amp; __node_gen)</span>
<span id="L903"><span class="lineNum">     903</span>              :         {</span>
<span id="L904"><span class="lineNum">     904</span>              :           return _M_insert_unique(</span>
<span id="L905"><span class="lineNum">     905</span>              :             _S_forward_key(_ExtractKey{}(std::forward&lt;_Arg&gt;(__arg))),</span>
<span id="L906"><span class="lineNum">     906</span>              :             std::forward&lt;_Arg&gt;(__arg), __node_gen);</span>
<span id="L907"><span class="lineNum">     907</span>              :         }</span>
<span id="L908"><span class="lineNum">     908</span>              : </span>
<span id="L909"><span class="lineNum">     909</span>              :       template&lt;typename _Arg, typename _NodeGenerator&gt;</span>
<span id="L910"><span class="lineNum">     910</span>              :         std::pair&lt;iterator, bool&gt;</span>
<span id="L911"><span class="lineNum">     911</span>              :         _M_insert(_Arg&amp;&amp; __arg, const _NodeGenerator&amp; __node_gen,</span>
<span id="L912"><span class="lineNum">     912</span>              :                   true_type /* __uks */)</span>
<span id="L913"><span class="lineNum">     913</span>              :         {</span>
<span id="L914"><span class="lineNum">     914</span>              :           using __to_value</span>
<span id="L915"><span class="lineNum">     915</span>              :             = __detail::_ConvertToValueType&lt;_ExtractKey, value_type&gt;;</span>
<span id="L916"><span class="lineNum">     916</span>              :           return _M_insert_unique_aux(</span>
<span id="L917"><span class="lineNum">     917</span>              :             __to_value{}(std::forward&lt;_Arg&gt;(__arg)), __node_gen);</span>
<span id="L918"><span class="lineNum">     918</span>              :         }</span>
<span id="L919"><span class="lineNum">     919</span>              : </span>
<span id="L920"><span class="lineNum">     920</span>              :       template&lt;typename _Arg, typename _NodeGenerator&gt;</span>
<span id="L921"><span class="lineNum">     921</span>              :         iterator</span>
<span id="L922"><span class="lineNum">     922</span>              :         _M_insert(_Arg&amp;&amp; __arg, const _NodeGenerator&amp; __node_gen,</span>
<span id="L923"><span class="lineNum">     923</span>              :                   false_type __uks)</span>
<span id="L924"><span class="lineNum">     924</span>              :         {</span>
<span id="L925"><span class="lineNum">     925</span>              :           using __to_value</span>
<span id="L926"><span class="lineNum">     926</span>              :             = __detail::_ConvertToValueType&lt;_ExtractKey, value_type&gt;;</span>
<span id="L927"><span class="lineNum">     927</span>              :           return _M_insert(cend(),</span>
<span id="L928"><span class="lineNum">     928</span>              :             __to_value{}(std::forward&lt;_Arg&gt;(__arg)), __node_gen, __uks);</span>
<span id="L929"><span class="lineNum">     929</span>              :         }</span>
<span id="L930"><span class="lineNum">     930</span>              : </span>
<span id="L931"><span class="lineNum">     931</span>              :       // Insert with hint, not used when keys are unique.</span>
<span id="L932"><span class="lineNum">     932</span>              :       template&lt;typename _Arg, typename _NodeGenerator&gt;</span>
<span id="L933"><span class="lineNum">     933</span>              :         iterator</span>
<span id="L934"><span class="lineNum">     934</span>              :         _M_insert(const_iterator, _Arg&amp;&amp; __arg,</span>
<span id="L935"><span class="lineNum">     935</span>              :                   const _NodeGenerator&amp; __node_gen, true_type __uks)</span>
<span id="L936"><span class="lineNum">     936</span>              :         {</span>
<span id="L937"><span class="lineNum">     937</span>              :           return</span>
<span id="L938"><span class="lineNum">     938</span>              :             _M_insert(std::forward&lt;_Arg&gt;(__arg), __node_gen, __uks).first;</span>
<span id="L939"><span class="lineNum">     939</span>              :         }</span>
<span id="L940"><span class="lineNum">     940</span>              : </span>
<span id="L941"><span class="lineNum">     941</span>              :       // Insert with hint when keys are not unique.</span>
<span id="L942"><span class="lineNum">     942</span>              :       template&lt;typename _Arg, typename _NodeGenerator&gt;</span>
<span id="L943"><span class="lineNum">     943</span>              :         iterator</span>
<span id="L944"><span class="lineNum">     944</span>              :         _M_insert(const_iterator, _Arg&amp;&amp;,</span>
<span id="L945"><span class="lineNum">     945</span>              :                   const _NodeGenerator&amp;, false_type __uks);</span>
<span id="L946"><span class="lineNum">     946</span>              : </span>
<span id="L947"><span class="lineNum">     947</span>              :       size_type</span>
<span id="L948"><span class="lineNum">     948</span>              :       _M_erase(true_type __uks, const key_type&amp;);</span>
<span id="L949"><span class="lineNum">     949</span>              : </span>
<span id="L950"><span class="lineNum">     950</span>              :       size_type</span>
<span id="L951"><span class="lineNum">     951</span>              :       _M_erase(false_type __uks, const key_type&amp;);</span>
<span id="L952"><span class="lineNum">     952</span>              : </span>
<span id="L953"><span class="lineNum">     953</span>              :       iterator</span>
<span id="L954"><span class="lineNum">     954</span>              :       _M_erase(size_type __bkt, __node_base_ptr __prev_n, __node_ptr __n);</span>
<span id="L955"><span class="lineNum">     955</span>              : </span>
<span id="L956"><span class="lineNum">     956</span>              :     public:</span>
<span id="L957"><span class="lineNum">     957</span>              :       // Emplace</span>
<span id="L958"><span class="lineNum">     958</span>              :       template&lt;typename... _Args&gt;</span>
<span id="L959"><span class="lineNum">     959</span>              :         __ireturn_type</span>
<span id="L960"><span class="lineNum">     960</span>              :         emplace(_Args&amp;&amp;... __args)</span>
<span id="L961"><span class="lineNum">     961</span>              :         { return _M_emplace(__unique_keys{}, std::forward&lt;_Args&gt;(__args)...); }</span>
<span id="L962"><span class="lineNum">     962</span>              : </span>
<span id="L963"><span class="lineNum">     963</span>              :       template&lt;typename... _Args&gt;</span>
<span id="L964"><span class="lineNum">     964</span>              :         iterator</span>
<span id="L965"><span class="lineNum">     965</span>              :         emplace_hint(const_iterator __hint, _Args&amp;&amp;... __args)</span>
<span id="L966"><span class="lineNum">     966</span>              :         {</span>
<span id="L967"><span class="lineNum">     967</span>              :           return _M_emplace(__hint, __unique_keys{},</span>
<span id="L968"><span class="lineNum">     968</span>              :                             std::forward&lt;_Args&gt;(__args)...);</span>
<span id="L969"><span class="lineNum">     969</span>              :         }</span>
<span id="L970"><span class="lineNum">     970</span>              : </span>
<span id="L971"><span class="lineNum">     971</span>              :       // Insert member functions via inheritance.</span>
<span id="L972"><span class="lineNum">     972</span>              : </span>
<span id="L973"><span class="lineNum">     973</span>              :       // Erase</span>
<span id="L974"><span class="lineNum">     974</span>              :       iterator</span>
<span id="L975"><span class="lineNum">     975</span>              :       erase(const_iterator);</span>
<span id="L976"><span class="lineNum">     976</span>              : </span>
<span id="L977"><span class="lineNum">     977</span>              :       // LWG 2059.</span>
<span id="L978"><span class="lineNum">     978</span>              :       iterator</span>
<span id="L979"><span class="lineNum">     979</span>              :       erase(iterator __it)</span>
<span id="L980"><span class="lineNum">     980</span>              :       { return erase(const_iterator(__it)); }</span>
<span id="L981"><span class="lineNum">     981</span>              : </span>
<span id="L982"><span class="lineNum">     982</span>              :       size_type</span>
<span id="L983"><span class="lineNum">     983</span> <span class="tlaUNC tlaBgUNC">           0 :       erase(const key_type&amp; __k)</span></span>
<span id="L984"><span class="lineNum">     984</span> <span class="tlaUNC">           0 :       { return _M_erase(__unique_keys{}, __k); }</span></span>
<span id="L985"><span class="lineNum">     985</span>              : </span>
<span id="L986"><span class="lineNum">     986</span>              :       iterator</span>
<span id="L987"><span class="lineNum">     987</span>              :       erase(const_iterator, const_iterator);</span>
<span id="L988"><span class="lineNum">     988</span>              : </span>
<span id="L989"><span class="lineNum">     989</span>              :       void</span>
<span id="L990"><span class="lineNum">     990</span>              :       clear() noexcept;</span>
<span id="L991"><span class="lineNum">     991</span>              : </span>
<span id="L992"><span class="lineNum">     992</span>              :       // Set number of buckets keeping it appropriate for container's number</span>
<span id="L993"><span class="lineNum">     993</span>              :       // of elements.</span>
<span id="L994"><span class="lineNum">     994</span>              :       void rehash(size_type __bkt_count);</span>
<span id="L995"><span class="lineNum">     995</span>              : </span>
<span id="L996"><span class="lineNum">     996</span>              :       // DR 1189.</span>
<span id="L997"><span class="lineNum">     997</span>              :       // reserve, if present, comes from _Rehash_base.</span>
<span id="L998"><span class="lineNum">     998</span>              : </span>
<span id="L999"><span class="lineNum">     999</span>              : #if __cplusplus &gt; 201404L</span>
<span id="L1000"><span class="lineNum">    1000</span>              :       /// Re-insert an extracted node into a container with unique keys.</span>
<span id="L1001"><span class="lineNum">    1001</span>              :       insert_return_type</span>
<span id="L1002"><span class="lineNum">    1002</span>              :       _M_reinsert_node(node_type&amp;&amp; __nh)</span>
<span id="L1003"><span class="lineNum">    1003</span>              :       {</span>
<span id="L1004"><span class="lineNum">    1004</span>              :         insert_return_type __ret;</span>
<span id="L1005"><span class="lineNum">    1005</span>              :         if (__nh.empty())</span>
<span id="L1006"><span class="lineNum">    1006</span>              :           __ret.position = end();</span>
<span id="L1007"><span class="lineNum">    1007</span>              :         else</span>
<span id="L1008"><span class="lineNum">    1008</span>              :           {</span>
<span id="L1009"><span class="lineNum">    1009</span>              :             __glibcxx_assert(get_allocator() == __nh.get_allocator());</span>
<span id="L1010"><span class="lineNum">    1010</span>              : </span>
<span id="L1011"><span class="lineNum">    1011</span>              :             const key_type&amp; __k = __nh._M_key();</span>
<span id="L1012"><span class="lineNum">    1012</span>              :             __hash_code __code = this-&gt;_M_hash_code(__k);</span>
<span id="L1013"><span class="lineNum">    1013</span>              :             size_type __bkt = _M_bucket_index(__code);</span>
<span id="L1014"><span class="lineNum">    1014</span>              :             if (__node_ptr __n = _M_find_node(__bkt, __k, __code))</span>
<span id="L1015"><span class="lineNum">    1015</span>              :               {</span>
<span id="L1016"><span class="lineNum">    1016</span>              :                 __ret.node = std::move(__nh);</span>
<span id="L1017"><span class="lineNum">    1017</span>              :                 __ret.position = iterator(__n);</span>
<span id="L1018"><span class="lineNum">    1018</span>              :                 __ret.inserted = false;</span>
<span id="L1019"><span class="lineNum">    1019</span>              :               }</span>
<span id="L1020"><span class="lineNum">    1020</span>              :             else</span>
<span id="L1021"><span class="lineNum">    1021</span>              :               {</span>
<span id="L1022"><span class="lineNum">    1022</span>              :                 __ret.position</span>
<span id="L1023"><span class="lineNum">    1023</span>              :                   = _M_insert_unique_node(__bkt, __code, __nh._M_ptr);</span>
<span id="L1024"><span class="lineNum">    1024</span>              :                 __nh.release();</span>
<span id="L1025"><span class="lineNum">    1025</span>              :                 __ret.inserted = true;</span>
<span id="L1026"><span class="lineNum">    1026</span>              :               }</span>
<span id="L1027"><span class="lineNum">    1027</span>              :           }</span>
<span id="L1028"><span class="lineNum">    1028</span>              :         return __ret;</span>
<span id="L1029"><span class="lineNum">    1029</span>              :       }</span>
<span id="L1030"><span class="lineNum">    1030</span>              : </span>
<span id="L1031"><span class="lineNum">    1031</span>              :       /// Re-insert an extracted node into a container with equivalent keys.</span>
<span id="L1032"><span class="lineNum">    1032</span>              :       iterator</span>
<span id="L1033"><span class="lineNum">    1033</span>              :       _M_reinsert_node_multi(const_iterator __hint, node_type&amp;&amp; __nh)</span>
<span id="L1034"><span class="lineNum">    1034</span>              :       {</span>
<span id="L1035"><span class="lineNum">    1035</span>              :         if (__nh.empty())</span>
<span id="L1036"><span class="lineNum">    1036</span>              :           return end();</span>
<span id="L1037"><span class="lineNum">    1037</span>              : </span>
<span id="L1038"><span class="lineNum">    1038</span>              :         __glibcxx_assert(get_allocator() == __nh.get_allocator());</span>
<span id="L1039"><span class="lineNum">    1039</span>              : </span>
<span id="L1040"><span class="lineNum">    1040</span>              :         const key_type&amp; __k = __nh._M_key();</span>
<span id="L1041"><span class="lineNum">    1041</span>              :         auto __code = this-&gt;_M_hash_code(__k);</span>
<span id="L1042"><span class="lineNum">    1042</span>              :         auto __ret</span>
<span id="L1043"><span class="lineNum">    1043</span>              :           = _M_insert_multi_node(__hint._M_cur, __code, __nh._M_ptr);</span>
<span id="L1044"><span class="lineNum">    1044</span>              :         __nh.release();</span>
<span id="L1045"><span class="lineNum">    1045</span>              :         return __ret;</span>
<span id="L1046"><span class="lineNum">    1046</span>              :       }</span>
<span id="L1047"><span class="lineNum">    1047</span>              : </span>
<span id="L1048"><span class="lineNum">    1048</span>              :     private:</span>
<span id="L1049"><span class="lineNum">    1049</span>              :       node_type</span>
<span id="L1050"><span class="lineNum">    1050</span>              :       _M_extract_node(size_t __bkt, __node_base_ptr __prev_n)</span>
<span id="L1051"><span class="lineNum">    1051</span>              :       {</span>
<span id="L1052"><span class="lineNum">    1052</span>              :         __node_ptr __n = static_cast&lt;__node_ptr&gt;(__prev_n-&gt;_M_nxt);</span>
<span id="L1053"><span class="lineNum">    1053</span>              :         if (__prev_n == _M_buckets[__bkt])</span>
<span id="L1054"><span class="lineNum">    1054</span>              :           _M_remove_bucket_begin(__bkt, __n-&gt;_M_next(),</span>
<span id="L1055"><span class="lineNum">    1055</span>              :              __n-&gt;_M_nxt ? _M_bucket_index(*__n-&gt;_M_next()) : 0);</span>
<span id="L1056"><span class="lineNum">    1056</span>              :         else if (__n-&gt;_M_nxt)</span>
<span id="L1057"><span class="lineNum">    1057</span>              :           {</span>
<span id="L1058"><span class="lineNum">    1058</span>              :             size_type __next_bkt = _M_bucket_index(*__n-&gt;_M_next());</span>
<span id="L1059"><span class="lineNum">    1059</span>              :             if (__next_bkt != __bkt)</span>
<span id="L1060"><span class="lineNum">    1060</span>              :               _M_buckets[__next_bkt] = __prev_n;</span>
<span id="L1061"><span class="lineNum">    1061</span>              :           }</span>
<span id="L1062"><span class="lineNum">    1062</span>              : </span>
<span id="L1063"><span class="lineNum">    1063</span>              :         __prev_n-&gt;_M_nxt = __n-&gt;_M_nxt;</span>
<span id="L1064"><span class="lineNum">    1064</span>              :         __n-&gt;_M_nxt = nullptr;</span>
<span id="L1065"><span class="lineNum">    1065</span>              :         --_M_element_count;</span>
<span id="L1066"><span class="lineNum">    1066</span>              :         return { __n, this-&gt;_M_node_allocator() };</span>
<span id="L1067"><span class="lineNum">    1067</span>              :       }</span>
<span id="L1068"><span class="lineNum">    1068</span>              : </span>
<span id="L1069"><span class="lineNum">    1069</span>              :       // Only use the possibly cached node's hash code if its hash function</span>
<span id="L1070"><span class="lineNum">    1070</span>              :       // _H2 matches _Hash and is stateless. Otherwise recompute it using _Hash.</span>
<span id="L1071"><span class="lineNum">    1071</span>              :       template&lt;typename _H2&gt;</span>
<span id="L1072"><span class="lineNum">    1072</span>              :         __hash_code</span>
<span id="L1073"><span class="lineNum">    1073</span>              :         _M_src_hash_code(const _H2&amp;, const key_type&amp; __k,</span>
<span id="L1074"><span class="lineNum">    1074</span>              :                          const __node_value_type&amp; __src_n) const</span>
<span id="L1075"><span class="lineNum">    1075</span>              :         {</span>
<span id="L1076"><span class="lineNum">    1076</span>              :           if constexpr (std::is_same_v&lt;_H2, _Hash&gt;)</span>
<span id="L1077"><span class="lineNum">    1077</span>              :             if constexpr (std::is_empty_v&lt;_Hash&gt;)</span>
<span id="L1078"><span class="lineNum">    1078</span>              :               return this-&gt;_M_hash_code(__src_n);</span>
<span id="L1079"><span class="lineNum">    1079</span>              : </span>
<span id="L1080"><span class="lineNum">    1080</span>              :           return this-&gt;_M_hash_code(__k);</span>
<span id="L1081"><span class="lineNum">    1081</span>              :         }</span>
<span id="L1082"><span class="lineNum">    1082</span>              : </span>
<span id="L1083"><span class="lineNum">    1083</span>              :     public:</span>
<span id="L1084"><span class="lineNum">    1084</span>              :       // Extract a node.</span>
<span id="L1085"><span class="lineNum">    1085</span>              :       node_type</span>
<span id="L1086"><span class="lineNum">    1086</span>              :       extract(const_iterator __pos)</span>
<span id="L1087"><span class="lineNum">    1087</span>              :       {</span>
<span id="L1088"><span class="lineNum">    1088</span>              :         size_t __bkt = _M_bucket_index(*__pos._M_cur);</span>
<span id="L1089"><span class="lineNum">    1089</span>              :         return _M_extract_node(__bkt,</span>
<span id="L1090"><span class="lineNum">    1090</span>              :                                _M_get_previous_node(__bkt, __pos._M_cur));</span>
<span id="L1091"><span class="lineNum">    1091</span>              :       }</span>
<span id="L1092"><span class="lineNum">    1092</span>              : </span>
<span id="L1093"><span class="lineNum">    1093</span>              :       /// Extract a node.</span>
<span id="L1094"><span class="lineNum">    1094</span>              :       node_type</span>
<span id="L1095"><span class="lineNum">    1095</span>              :       extract(const _Key&amp; __k)</span>
<span id="L1096"><span class="lineNum">    1096</span>              :       {</span>
<span id="L1097"><span class="lineNum">    1097</span>              :         node_type __nh;</span>
<span id="L1098"><span class="lineNum">    1098</span>              :         __hash_code __code = this-&gt;_M_hash_code(__k);</span>
<span id="L1099"><span class="lineNum">    1099</span>              :         std::size_t __bkt = _M_bucket_index(__code);</span>
<span id="L1100"><span class="lineNum">    1100</span>              :         if (__node_base_ptr __prev_node = _M_find_before_node(__bkt, __k, __code))</span>
<span id="L1101"><span class="lineNum">    1101</span>              :           __nh = _M_extract_node(__bkt, __prev_node);</span>
<span id="L1102"><span class="lineNum">    1102</span>              :         return __nh;</span>
<span id="L1103"><span class="lineNum">    1103</span>              :       }</span>
<span id="L1104"><span class="lineNum">    1104</span>              : </span>
<span id="L1105"><span class="lineNum">    1105</span>              :       /// Merge from a compatible container into one with unique keys.</span>
<span id="L1106"><span class="lineNum">    1106</span>              :       template&lt;typename _Compatible_Hashtable&gt;</span>
<span id="L1107"><span class="lineNum">    1107</span>              :         void</span>
<span id="L1108"><span class="lineNum">    1108</span>              :         _M_merge_unique(_Compatible_Hashtable&amp; __src)</span>
<span id="L1109"><span class="lineNum">    1109</span>              :         {</span>
<span id="L1110"><span class="lineNum">    1110</span>              :           static_assert(is_same_v&lt;typename _Compatible_Hashtable::node_type,</span>
<span id="L1111"><span class="lineNum">    1111</span>              :               node_type&gt;, &quot;Node types are compatible&quot;);</span>
<span id="L1112"><span class="lineNum">    1112</span>              :           __glibcxx_assert(get_allocator() == __src.get_allocator());</span>
<span id="L1113"><span class="lineNum">    1113</span>              : </span>
<span id="L1114"><span class="lineNum">    1114</span>              :           auto __n_elt = __src.size();</span>
<span id="L1115"><span class="lineNum">    1115</span>              :           for (auto __i = __src.cbegin(), __end = __src.cend(); __i != __end;)</span>
<span id="L1116"><span class="lineNum">    1116</span>              :             {</span>
<span id="L1117"><span class="lineNum">    1117</span>              :               auto __pos = __i++;</span>
<span id="L1118"><span class="lineNum">    1118</span>              :               const key_type&amp; __k = _ExtractKey{}(*__pos);</span>
<span id="L1119"><span class="lineNum">    1119</span>              :               __hash_code __code</span>
<span id="L1120"><span class="lineNum">    1120</span>              :                 = _M_src_hash_code(__src.hash_function(), __k, *__pos._M_cur);</span>
<span id="L1121"><span class="lineNum">    1121</span>              :               size_type __bkt = _M_bucket_index(__code);</span>
<span id="L1122"><span class="lineNum">    1122</span>              :               if (_M_find_node(__bkt, __k, __code) == nullptr)</span>
<span id="L1123"><span class="lineNum">    1123</span>              :                 {</span>
<span id="L1124"><span class="lineNum">    1124</span>              :                   auto __nh = __src.extract(__pos);</span>
<span id="L1125"><span class="lineNum">    1125</span>              :                   _M_insert_unique_node(__bkt, __code, __nh._M_ptr, __n_elt);</span>
<span id="L1126"><span class="lineNum">    1126</span>              :                   __nh.release();</span>
<span id="L1127"><span class="lineNum">    1127</span>              :                   __n_elt = 1;</span>
<span id="L1128"><span class="lineNum">    1128</span>              :                 }</span>
<span id="L1129"><span class="lineNum">    1129</span>              :               else if (__n_elt != 1)</span>
<span id="L1130"><span class="lineNum">    1130</span>              :                 --__n_elt;</span>
<span id="L1131"><span class="lineNum">    1131</span>              :             }</span>
<span id="L1132"><span class="lineNum">    1132</span>              :         }</span>
<span id="L1133"><span class="lineNum">    1133</span>              : </span>
<span id="L1134"><span class="lineNum">    1134</span>              :       /// Merge from a compatible container into one with equivalent keys.</span>
<span id="L1135"><span class="lineNum">    1135</span>              :       template&lt;typename _Compatible_Hashtable&gt;</span>
<span id="L1136"><span class="lineNum">    1136</span>              :         void</span>
<span id="L1137"><span class="lineNum">    1137</span>              :         _M_merge_multi(_Compatible_Hashtable&amp; __src)</span>
<span id="L1138"><span class="lineNum">    1138</span>              :         {</span>
<span id="L1139"><span class="lineNum">    1139</span>              :           static_assert(is_same_v&lt;typename _Compatible_Hashtable::node_type,</span>
<span id="L1140"><span class="lineNum">    1140</span>              :               node_type&gt;, &quot;Node types are compatible&quot;);</span>
<span id="L1141"><span class="lineNum">    1141</span>              :           __glibcxx_assert(get_allocator() == __src.get_allocator());</span>
<span id="L1142"><span class="lineNum">    1142</span>              : </span>
<span id="L1143"><span class="lineNum">    1143</span>              :           __node_ptr __hint = nullptr;</span>
<span id="L1144"><span class="lineNum">    1144</span>              :           this-&gt;reserve(size() + __src.size());</span>
<span id="L1145"><span class="lineNum">    1145</span>              :           for (auto __i = __src.cbegin(), __end = __src.cend(); __i != __end;)</span>
<span id="L1146"><span class="lineNum">    1146</span>              :             {</span>
<span id="L1147"><span class="lineNum">    1147</span>              :               auto __pos = __i++;</span>
<span id="L1148"><span class="lineNum">    1148</span>              :               const key_type&amp; __k = _ExtractKey{}(*__pos);</span>
<span id="L1149"><span class="lineNum">    1149</span>              :               __hash_code __code</span>
<span id="L1150"><span class="lineNum">    1150</span>              :                 = _M_src_hash_code(__src.hash_function(), __k, *__pos._M_cur);</span>
<span id="L1151"><span class="lineNum">    1151</span>              :               auto __nh = __src.extract(__pos);</span>
<span id="L1152"><span class="lineNum">    1152</span>              :               __hint = _M_insert_multi_node(__hint, __code, __nh._M_ptr)._M_cur;</span>
<span id="L1153"><span class="lineNum">    1153</span>              :               __nh.release();</span>
<span id="L1154"><span class="lineNum">    1154</span>              :             }</span>
<span id="L1155"><span class="lineNum">    1155</span>              :         }</span>
<span id="L1156"><span class="lineNum">    1156</span>              : #endif // C++17</span>
<span id="L1157"><span class="lineNum">    1157</span>              : </span>
<span id="L1158"><span class="lineNum">    1158</span>              :     private:</span>
<span id="L1159"><span class="lineNum">    1159</span>              :       // Helper rehash method used when keys are unique.</span>
<span id="L1160"><span class="lineNum">    1160</span>              :       void _M_rehash_aux(size_type __bkt_count, true_type __uks);</span>
<span id="L1161"><span class="lineNum">    1161</span>              : </span>
<span id="L1162"><span class="lineNum">    1162</span>              :       // Helper rehash method used when keys can be non-unique.</span>
<span id="L1163"><span class="lineNum">    1163</span>              :       void _M_rehash_aux(size_type __bkt_count, false_type __uks);</span>
<span id="L1164"><span class="lineNum">    1164</span>              : </span>
<span id="L1165"><span class="lineNum">    1165</span>              :       // Unconditionally change size of bucket array to n, restore</span>
<span id="L1166"><span class="lineNum">    1166</span>              :       // hash policy state to __state on exception.</span>
<span id="L1167"><span class="lineNum">    1167</span>              :       void _M_rehash(size_type __bkt_count, const __rehash_state&amp; __state);</span>
<span id="L1168"><span class="lineNum">    1168</span>              :     };</span>
<span id="L1169"><span class="lineNum">    1169</span>              : </span>
<span id="L1170"><span class="lineNum">    1170</span>              :   // Definitions of class template _Hashtable's out-of-line member functions.</span>
<span id="L1171"><span class="lineNum">    1171</span>              :   template&lt;typename _Key, typename _Value, typename _Alloc,</span>
<span id="L1172"><span class="lineNum">    1172</span>              :            typename _ExtractKey, typename _Equal,</span>
<span id="L1173"><span class="lineNum">    1173</span>              :            typename _Hash, typename _RangeHash, typename _Unused,</span>
<span id="L1174"><span class="lineNum">    1174</span>              :            typename _RehashPolicy, typename _Traits&gt;</span>
<span id="L1175"><span class="lineNum">    1175</span>              :     auto</span>
<span id="L1176"><span class="lineNum">    1176</span>              :     _Hashtable&lt;_Key, _Value, _Alloc, _ExtractKey, _Equal,</span>
<span id="L1177"><span class="lineNum">    1177</span>              :                _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits&gt;::</span>
<span id="L1178"><span class="lineNum">    1178</span>              :     _M_bucket_begin(size_type __bkt) const</span>
<span id="L1179"><span class="lineNum">    1179</span>              :     -&gt; __node_ptr</span>
<span id="L1180"><span class="lineNum">    1180</span>              :     {</span>
<span id="L1181"><span class="lineNum">    1181</span>              :       __node_base_ptr __n = _M_buckets[__bkt];</span>
<span id="L1182"><span class="lineNum">    1182</span>              :       return __n ? static_cast&lt;__node_ptr&gt;(__n-&gt;_M_nxt) : nullptr;</span>
<span id="L1183"><span class="lineNum">    1183</span>              :     }</span>
<span id="L1184"><span class="lineNum">    1184</span>              : </span>
<span id="L1185"><span class="lineNum">    1185</span>              :   template&lt;typename _Key, typename _Value, typename _Alloc,</span>
<span id="L1186"><span class="lineNum">    1186</span>              :            typename _ExtractKey, typename _Equal,</span>
<span id="L1187"><span class="lineNum">    1187</span>              :            typename _Hash, typename _RangeHash, typename _Unused,</span>
<span id="L1188"><span class="lineNum">    1188</span>              :            typename _RehashPolicy, typename _Traits&gt;</span>
<span id="L1189"><span class="lineNum">    1189</span>              :     _Hashtable&lt;_Key, _Value, _Alloc, _ExtractKey, _Equal,</span>
<span id="L1190"><span class="lineNum">    1190</span>              :                _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits&gt;::</span>
<span id="L1191"><span class="lineNum">    1191</span>              :     _Hashtable(size_type __bkt_count_hint,</span>
<span id="L1192"><span class="lineNum">    1192</span>              :                const _Hash&amp; __h, const _Equal&amp; __eq, const allocator_type&amp; __a)</span>
<span id="L1193"><span class="lineNum">    1193</span>              :     : _Hashtable(__h, __eq, __a)</span>
<span id="L1194"><span class="lineNum">    1194</span>              :     {</span>
<span id="L1195"><span class="lineNum">    1195</span>              :       auto __bkt_count = _M_rehash_policy._M_next_bkt(__bkt_count_hint);</span>
<span id="L1196"><span class="lineNum">    1196</span>              :       if (__bkt_count &gt; _M_bucket_count)</span>
<span id="L1197"><span class="lineNum">    1197</span>              :         {</span>
<span id="L1198"><span class="lineNum">    1198</span>              :           _M_buckets = _M_allocate_buckets(__bkt_count);</span>
<span id="L1199"><span class="lineNum">    1199</span>              :           _M_bucket_count = __bkt_count;</span>
<span id="L1200"><span class="lineNum">    1200</span>              :         }</span>
<span id="L1201"><span class="lineNum">    1201</span>              :     }</span>
<span id="L1202"><span class="lineNum">    1202</span>              : </span>
<span id="L1203"><span class="lineNum">    1203</span>              :   template&lt;typename _Key, typename _Value, typename _Alloc,</span>
<span id="L1204"><span class="lineNum">    1204</span>              :            typename _ExtractKey, typename _Equal,</span>
<span id="L1205"><span class="lineNum">    1205</span>              :            typename _Hash, typename _RangeHash, typename _Unused,</span>
<span id="L1206"><span class="lineNum">    1206</span>              :            typename _RehashPolicy, typename _Traits&gt;</span>
<span id="L1207"><span class="lineNum">    1207</span>              :     template&lt;typename _InputIterator&gt;</span>
<span id="L1208"><span class="lineNum">    1208</span>              :       _Hashtable&lt;_Key, _Value, _Alloc, _ExtractKey, _Equal,</span>
<span id="L1209"><span class="lineNum">    1209</span>              :                  _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits&gt;::</span>
<span id="L1210"><span class="lineNum">    1210</span>              :       _Hashtable(_InputIterator __f, _InputIterator __l,</span>
<span id="L1211"><span class="lineNum">    1211</span>              :                  size_type __bkt_count_hint,</span>
<span id="L1212"><span class="lineNum">    1212</span>              :                  const _Hash&amp; __h, const _Equal&amp; __eq,</span>
<span id="L1213"><span class="lineNum">    1213</span>              :                  const allocator_type&amp; __a, true_type /* __uks */)</span>
<span id="L1214"><span class="lineNum">    1214</span>              :       : _Hashtable(__bkt_count_hint, __h, __eq, __a)</span>
<span id="L1215"><span class="lineNum">    1215</span>              :       { this-&gt;insert(__f, __l); }</span>
<span id="L1216"><span class="lineNum">    1216</span>              : </span>
<span id="L1217"><span class="lineNum">    1217</span>              :   template&lt;typename _Key, typename _Value, typename _Alloc,</span>
<span id="L1218"><span class="lineNum">    1218</span>              :            typename _ExtractKey, typename _Equal,</span>
<span id="L1219"><span class="lineNum">    1219</span>              :            typename _Hash, typename _RangeHash, typename _Unused,</span>
<span id="L1220"><span class="lineNum">    1220</span>              :            typename _RehashPolicy, typename _Traits&gt;</span>
<span id="L1221"><span class="lineNum">    1221</span>              :     template&lt;typename _InputIterator&gt;</span>
<span id="L1222"><span class="lineNum">    1222</span>              :       _Hashtable&lt;_Key, _Value, _Alloc, _ExtractKey, _Equal,</span>
<span id="L1223"><span class="lineNum">    1223</span>              :                  _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits&gt;::</span>
<span id="L1224"><span class="lineNum">    1224</span>              :       _Hashtable(_InputIterator __f, _InputIterator __l,</span>
<span id="L1225"><span class="lineNum">    1225</span>              :                  size_type __bkt_count_hint,</span>
<span id="L1226"><span class="lineNum">    1226</span>              :                  const _Hash&amp; __h, const _Equal&amp; __eq,</span>
<span id="L1227"><span class="lineNum">    1227</span>              :                  const allocator_type&amp; __a, false_type __uks)</span>
<span id="L1228"><span class="lineNum">    1228</span>              :       : _Hashtable(__h, __eq, __a)</span>
<span id="L1229"><span class="lineNum">    1229</span>              :       {</span>
<span id="L1230"><span class="lineNum">    1230</span>              :         auto __nb_elems = __detail::__distance_fw(__f, __l);</span>
<span id="L1231"><span class="lineNum">    1231</span>              :         auto __bkt_count =</span>
<span id="L1232"><span class="lineNum">    1232</span>              :           _M_rehash_policy._M_next_bkt(</span>
<span id="L1233"><span class="lineNum">    1233</span>              :             std::max(_M_rehash_policy._M_bkt_for_elements(__nb_elems),</span>
<span id="L1234"><span class="lineNum">    1234</span>              :                      __bkt_count_hint));</span>
<span id="L1235"><span class="lineNum">    1235</span>              : </span>
<span id="L1236"><span class="lineNum">    1236</span>              :         if (__bkt_count &gt; _M_bucket_count)</span>
<span id="L1237"><span class="lineNum">    1237</span>              :           {</span>
<span id="L1238"><span class="lineNum">    1238</span>              :             _M_buckets = _M_allocate_buckets(__bkt_count);</span>
<span id="L1239"><span class="lineNum">    1239</span>              :             _M_bucket_count = __bkt_count;</span>
<span id="L1240"><span class="lineNum">    1240</span>              :           }</span>
<span id="L1241"><span class="lineNum">    1241</span>              : </span>
<span id="L1242"><span class="lineNum">    1242</span>              :         __alloc_node_gen_t __node_gen(*this);</span>
<span id="L1243"><span class="lineNum">    1243</span>              :         for (; __f != __l; ++__f)</span>
<span id="L1244"><span class="lineNum">    1244</span>              :           _M_insert(*__f, __node_gen, __uks);</span>
<span id="L1245"><span class="lineNum">    1245</span>              :       }</span>
<span id="L1246"><span class="lineNum">    1246</span>              : </span>
<span id="L1247"><span class="lineNum">    1247</span>              :   template&lt;typename _Key, typename _Value, typename _Alloc,</span>
<span id="L1248"><span class="lineNum">    1248</span>              :            typename _ExtractKey, typename _Equal,</span>
<span id="L1249"><span class="lineNum">    1249</span>              :            typename _Hash, typename _RangeHash, typename _Unused,</span>
<span id="L1250"><span class="lineNum">    1250</span>              :            typename _RehashPolicy, typename _Traits&gt;</span>
<span id="L1251"><span class="lineNum">    1251</span>              :     auto</span>
<span id="L1252"><span class="lineNum">    1252</span>              :     _Hashtable&lt;_Key, _Value, _Alloc, _ExtractKey, _Equal,</span>
<span id="L1253"><span class="lineNum">    1253</span>              :                _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits&gt;::</span>
<span id="L1254"><span class="lineNum">    1254</span>              :     operator=(const _Hashtable&amp; __ht)</span>
<span id="L1255"><span class="lineNum">    1255</span>              :     -&gt; _Hashtable&amp;</span>
<span id="L1256"><span class="lineNum">    1256</span>              :     {</span>
<span id="L1257"><span class="lineNum">    1257</span>              :       if (&amp;__ht == this)</span>
<span id="L1258"><span class="lineNum">    1258</span>              :         return *this;</span>
<span id="L1259"><span class="lineNum">    1259</span>              : </span>
<span id="L1260"><span class="lineNum">    1260</span>              :       if (__node_alloc_traits::_S_propagate_on_copy_assign())</span>
<span id="L1261"><span class="lineNum">    1261</span>              :         {</span>
<span id="L1262"><span class="lineNum">    1262</span>              :           auto&amp; __this_alloc = this-&gt;_M_node_allocator();</span>
<span id="L1263"><span class="lineNum">    1263</span>              :           auto&amp; __that_alloc = __ht._M_node_allocator();</span>
<span id="L1264"><span class="lineNum">    1264</span>              :           if (!__node_alloc_traits::_S_always_equal()</span>
<span id="L1265"><span class="lineNum">    1265</span>              :               &amp;&amp; __this_alloc != __that_alloc)</span>
<span id="L1266"><span class="lineNum">    1266</span>              :             {</span>
<span id="L1267"><span class="lineNum">    1267</span>              :               // Replacement allocator cannot free existing storage.</span>
<span id="L1268"><span class="lineNum">    1268</span>              :               this-&gt;_M_deallocate_nodes(_M_begin());</span>
<span id="L1269"><span class="lineNum">    1269</span>              :               _M_before_begin._M_nxt = nullptr;</span>
<span id="L1270"><span class="lineNum">    1270</span>              :               _M_deallocate_buckets();</span>
<span id="L1271"><span class="lineNum">    1271</span>              :               _M_buckets = nullptr;</span>
<span id="L1272"><span class="lineNum">    1272</span>              :               std::__alloc_on_copy(__this_alloc, __that_alloc);</span>
<span id="L1273"><span class="lineNum">    1273</span>              :               __hashtable_base::operator=(__ht);</span>
<span id="L1274"><span class="lineNum">    1274</span>              :               _M_bucket_count = __ht._M_bucket_count;</span>
<span id="L1275"><span class="lineNum">    1275</span>              :               _M_element_count = __ht._M_element_count;</span>
<span id="L1276"><span class="lineNum">    1276</span>              :               _M_rehash_policy = __ht._M_rehash_policy;</span>
<span id="L1277"><span class="lineNum">    1277</span>              :               __alloc_node_gen_t __alloc_node_gen(*this);</span>
<span id="L1278"><span class="lineNum">    1278</span>              :               __try</span>
<span id="L1279"><span class="lineNum">    1279</span>              :                 {</span>
<span id="L1280"><span class="lineNum">    1280</span>              :                   _M_assign(__ht, __alloc_node_gen);</span>
<span id="L1281"><span class="lineNum">    1281</span>              :                 }</span>
<span id="L1282"><span class="lineNum">    1282</span>              :               __catch(...)</span>
<span id="L1283"><span class="lineNum">    1283</span>              :                 {</span>
<span id="L1284"><span class="lineNum">    1284</span>              :                   // _M_assign took care of deallocating all memory. Now we</span>
<span id="L1285"><span class="lineNum">    1285</span>              :                   // must make sure this instance remains in a usable state.</span>
<span id="L1286"><span class="lineNum">    1286</span>              :                   _M_reset();</span>
<span id="L1287"><span class="lineNum">    1287</span>              :                   __throw_exception_again;</span>
<span id="L1288"><span class="lineNum">    1288</span>              :                 }</span>
<span id="L1289"><span class="lineNum">    1289</span>              :               return *this;</span>
<span id="L1290"><span class="lineNum">    1290</span>              :             }</span>
<span id="L1291"><span class="lineNum">    1291</span>              :           std::__alloc_on_copy(__this_alloc, __that_alloc);</span>
<span id="L1292"><span class="lineNum">    1292</span>              :         }</span>
<span id="L1293"><span class="lineNum">    1293</span>              : </span>
<span id="L1294"><span class="lineNum">    1294</span>              :       // Reuse allocated buckets and nodes.</span>
<span id="L1295"><span class="lineNum">    1295</span>              :       _M_assign_elements(__ht);</span>
<span id="L1296"><span class="lineNum">    1296</span>              :       return *this;</span>
<span id="L1297"><span class="lineNum">    1297</span>              :     }</span>
<span id="L1298"><span class="lineNum">    1298</span>              : </span>
<span id="L1299"><span class="lineNum">    1299</span>              :   template&lt;typename _Key, typename _Value, typename _Alloc,</span>
<span id="L1300"><span class="lineNum">    1300</span>              :            typename _ExtractKey, typename _Equal,</span>
<span id="L1301"><span class="lineNum">    1301</span>              :            typename _Hash, typename _RangeHash, typename _Unused,</span>
<span id="L1302"><span class="lineNum">    1302</span>              :            typename _RehashPolicy, typename _Traits&gt;</span>
<span id="L1303"><span class="lineNum">    1303</span>              :     template&lt;typename _Ht&gt;</span>
<span id="L1304"><span class="lineNum">    1304</span>              :       void</span>
<span id="L1305"><span class="lineNum">    1305</span>              :       _Hashtable&lt;_Key, _Value, _Alloc, _ExtractKey, _Equal,</span>
<span id="L1306"><span class="lineNum">    1306</span>              :                  _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits&gt;::</span>
<span id="L1307"><span class="lineNum">    1307</span>              :       _M_assign_elements(_Ht&amp;&amp; __ht)</span>
<span id="L1308"><span class="lineNum">    1308</span>              :       {</span>
<span id="L1309"><span class="lineNum">    1309</span>              :         __buckets_ptr __former_buckets = nullptr;</span>
<span id="L1310"><span class="lineNum">    1310</span>              :         std::size_t __former_bucket_count = _M_bucket_count;</span>
<span id="L1311"><span class="lineNum">    1311</span>              :         const __rehash_state&amp; __former_state = _M_rehash_policy._M_state();</span>
<span id="L1312"><span class="lineNum">    1312</span>              : </span>
<span id="L1313"><span class="lineNum">    1313</span>              :         if (_M_bucket_count != __ht._M_bucket_count)</span>
<span id="L1314"><span class="lineNum">    1314</span>              :           {</span>
<span id="L1315"><span class="lineNum">    1315</span>              :             __former_buckets = _M_buckets;</span>
<span id="L1316"><span class="lineNum">    1316</span>              :             _M_buckets = _M_allocate_buckets(__ht._M_bucket_count);</span>
<span id="L1317"><span class="lineNum">    1317</span>              :             _M_bucket_count = __ht._M_bucket_count;</span>
<span id="L1318"><span class="lineNum">    1318</span>              :           }</span>
<span id="L1319"><span class="lineNum">    1319</span>              :         else</span>
<span id="L1320"><span class="lineNum">    1320</span>              :           __builtin_memset(_M_buckets, 0,</span>
<span id="L1321"><span class="lineNum">    1321</span>              :                            _M_bucket_count * sizeof(__node_base_ptr));</span>
<span id="L1322"><span class="lineNum">    1322</span>              : </span>
<span id="L1323"><span class="lineNum">    1323</span>              :         __try</span>
<span id="L1324"><span class="lineNum">    1324</span>              :           {</span>
<span id="L1325"><span class="lineNum">    1325</span>              :             __hashtable_base::operator=(std::forward&lt;_Ht&gt;(__ht));</span>
<span id="L1326"><span class="lineNum">    1326</span>              :             _M_element_count = __ht._M_element_count;</span>
<span id="L1327"><span class="lineNum">    1327</span>              :             _M_rehash_policy = __ht._M_rehash_policy;</span>
<span id="L1328"><span class="lineNum">    1328</span>              :             __reuse_or_alloc_node_gen_t __roan(_M_begin(), *this);</span>
<span id="L1329"><span class="lineNum">    1329</span>              :             _M_before_begin._M_nxt = nullptr;</span>
<span id="L1330"><span class="lineNum">    1330</span>              :             _M_assign(std::forward&lt;_Ht&gt;(__ht), __roan);</span>
<span id="L1331"><span class="lineNum">    1331</span>              :             if (__former_buckets)</span>
<span id="L1332"><span class="lineNum">    1332</span>              :               _M_deallocate_buckets(__former_buckets, __former_bucket_count);</span>
<span id="L1333"><span class="lineNum">    1333</span>              :           }</span>
<span id="L1334"><span class="lineNum">    1334</span>              :         __catch(...)</span>
<span id="L1335"><span class="lineNum">    1335</span>              :           {</span>
<span id="L1336"><span class="lineNum">    1336</span>              :             if (__former_buckets)</span>
<span id="L1337"><span class="lineNum">    1337</span>              :               {</span>
<span id="L1338"><span class="lineNum">    1338</span>              :                 // Restore previous buckets.</span>
<span id="L1339"><span class="lineNum">    1339</span>              :                 _M_deallocate_buckets();</span>
<span id="L1340"><span class="lineNum">    1340</span>              :                 _M_rehash_policy._M_reset(__former_state);</span>
<span id="L1341"><span class="lineNum">    1341</span>              :                 _M_buckets = __former_buckets;</span>
<span id="L1342"><span class="lineNum">    1342</span>              :                 _M_bucket_count = __former_bucket_count;</span>
<span id="L1343"><span class="lineNum">    1343</span>              :               }</span>
<span id="L1344"><span class="lineNum">    1344</span>              :             __builtin_memset(_M_buckets, 0,</span>
<span id="L1345"><span class="lineNum">    1345</span>              :                              _M_bucket_count * sizeof(__node_base_ptr));</span>
<span id="L1346"><span class="lineNum">    1346</span>              :             __throw_exception_again;</span>
<span id="L1347"><span class="lineNum">    1347</span>              :           }</span>
<span id="L1348"><span class="lineNum">    1348</span>              :       }</span>
<span id="L1349"><span class="lineNum">    1349</span>              : </span>
<span id="L1350"><span class="lineNum">    1350</span>              :   template&lt;typename _Key, typename _Value, typename _Alloc,</span>
<span id="L1351"><span class="lineNum">    1351</span>              :            typename _ExtractKey, typename _Equal,</span>
<span id="L1352"><span class="lineNum">    1352</span>              :            typename _Hash, typename _RangeHash, typename _Unused,</span>
<span id="L1353"><span class="lineNum">    1353</span>              :            typename _RehashPolicy, typename _Traits&gt;</span>
<span id="L1354"><span class="lineNum">    1354</span>              :     template&lt;typename _Ht, typename _NodeGenerator&gt;</span>
<span id="L1355"><span class="lineNum">    1355</span>              :       void</span>
<span id="L1356"><span class="lineNum">    1356</span>              :       _Hashtable&lt;_Key, _Value, _Alloc, _ExtractKey, _Equal,</span>
<span id="L1357"><span class="lineNum">    1357</span>              :                  _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits&gt;::</span>
<span id="L1358"><span class="lineNum">    1358</span>              :       _M_assign(_Ht&amp;&amp; __ht, const _NodeGenerator&amp; __node_gen)</span>
<span id="L1359"><span class="lineNum">    1359</span>              :       {</span>
<span id="L1360"><span class="lineNum">    1360</span>              :         __buckets_ptr __buckets = nullptr;</span>
<span id="L1361"><span class="lineNum">    1361</span>              :         if (!_M_buckets)</span>
<span id="L1362"><span class="lineNum">    1362</span>              :           _M_buckets = __buckets = _M_allocate_buckets(_M_bucket_count);</span>
<span id="L1363"><span class="lineNum">    1363</span>              : </span>
<span id="L1364"><span class="lineNum">    1364</span>              :         __try</span>
<span id="L1365"><span class="lineNum">    1365</span>              :           {</span>
<span id="L1366"><span class="lineNum">    1366</span>              :             if (!__ht._M_before_begin._M_nxt)</span>
<span id="L1367"><span class="lineNum">    1367</span>              :               return;</span>
<span id="L1368"><span class="lineNum">    1368</span>              : </span>
<span id="L1369"><span class="lineNum">    1369</span>              :             // First deal with the special first node pointed to by</span>
<span id="L1370"><span class="lineNum">    1370</span>              :             // _M_before_begin.</span>
<span id="L1371"><span class="lineNum">    1371</span>              :             __node_ptr __ht_n = __ht._M_begin();</span>
<span id="L1372"><span class="lineNum">    1372</span>              :             __node_ptr __this_n</span>
<span id="L1373"><span class="lineNum">    1373</span>              :               = __node_gen(__fwd_value_for&lt;_Ht&gt;(__ht_n-&gt;_M_v()));</span>
<span id="L1374"><span class="lineNum">    1374</span>              :             this-&gt;_M_copy_code(*__this_n, *__ht_n);</span>
<span id="L1375"><span class="lineNum">    1375</span>              :             _M_update_bbegin(__this_n);</span>
<span id="L1376"><span class="lineNum">    1376</span>              : </span>
<span id="L1377"><span class="lineNum">    1377</span>              :             // Then deal with other nodes.</span>
<span id="L1378"><span class="lineNum">    1378</span>              :             __node_ptr __prev_n = __this_n;</span>
<span id="L1379"><span class="lineNum">    1379</span>              :             for (__ht_n = __ht_n-&gt;_M_next(); __ht_n; __ht_n = __ht_n-&gt;_M_next())</span>
<span id="L1380"><span class="lineNum">    1380</span>              :               {</span>
<span id="L1381"><span class="lineNum">    1381</span>              :                 __this_n = __node_gen(__fwd_value_for&lt;_Ht&gt;(__ht_n-&gt;_M_v()));</span>
<span id="L1382"><span class="lineNum">    1382</span>              :                 __prev_n-&gt;_M_nxt = __this_n;</span>
<span id="L1383"><span class="lineNum">    1383</span>              :                 this-&gt;_M_copy_code(*__this_n, *__ht_n);</span>
<span id="L1384"><span class="lineNum">    1384</span>              :                 size_type __bkt = _M_bucket_index(*__this_n);</span>
<span id="L1385"><span class="lineNum">    1385</span>              :                 if (!_M_buckets[__bkt])</span>
<span id="L1386"><span class="lineNum">    1386</span>              :                   _M_buckets[__bkt] = __prev_n;</span>
<span id="L1387"><span class="lineNum">    1387</span>              :                 __prev_n = __this_n;</span>
<span id="L1388"><span class="lineNum">    1388</span>              :               }</span>
<span id="L1389"><span class="lineNum">    1389</span>              :           }</span>
<span id="L1390"><span class="lineNum">    1390</span>              :         __catch(...)</span>
<span id="L1391"><span class="lineNum">    1391</span>              :           {</span>
<span id="L1392"><span class="lineNum">    1392</span>              :             clear();</span>
<span id="L1393"><span class="lineNum">    1393</span>              :             if (__buckets)</span>
<span id="L1394"><span class="lineNum">    1394</span>              :               _M_deallocate_buckets();</span>
<span id="L1395"><span class="lineNum">    1395</span>              :             __throw_exception_again;</span>
<span id="L1396"><span class="lineNum">    1396</span>              :           }</span>
<span id="L1397"><span class="lineNum">    1397</span>              :       }</span>
<span id="L1398"><span class="lineNum">    1398</span>              : </span>
<span id="L1399"><span class="lineNum">    1399</span>              :   template&lt;typename _Key, typename _Value, typename _Alloc,</span>
<span id="L1400"><span class="lineNum">    1400</span>              :            typename _ExtractKey, typename _Equal,</span>
<span id="L1401"><span class="lineNum">    1401</span>              :            typename _Hash, typename _RangeHash, typename _Unused,</span>
<span id="L1402"><span class="lineNum">    1402</span>              :            typename _RehashPolicy, typename _Traits&gt;</span>
<span id="L1403"><span class="lineNum">    1403</span>              :     void</span>
<span id="L1404"><span class="lineNum">    1404</span>              :     _Hashtable&lt;_Key, _Value, _Alloc, _ExtractKey, _Equal,</span>
<span id="L1405"><span class="lineNum">    1405</span>              :                _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits&gt;::</span>
<span id="L1406"><span class="lineNum">    1406</span>              :     _M_reset() noexcept</span>
<span id="L1407"><span class="lineNum">    1407</span>              :     {</span>
<span id="L1408"><span class="lineNum">    1408</span>              :       _M_rehash_policy._M_reset();</span>
<span id="L1409"><span class="lineNum">    1409</span>              :       _M_bucket_count = 1;</span>
<span id="L1410"><span class="lineNum">    1410</span>              :       _M_single_bucket = nullptr;</span>
<span id="L1411"><span class="lineNum">    1411</span>              :       _M_buckets = &amp;_M_single_bucket;</span>
<span id="L1412"><span class="lineNum">    1412</span>              :       _M_before_begin._M_nxt = nullptr;</span>
<span id="L1413"><span class="lineNum">    1413</span>              :       _M_element_count = 0;</span>
<span id="L1414"><span class="lineNum">    1414</span>              :     }</span>
<span id="L1415"><span class="lineNum">    1415</span>              : </span>
<span id="L1416"><span class="lineNum">    1416</span>              :   template&lt;typename _Key, typename _Value, typename _Alloc,</span>
<span id="L1417"><span class="lineNum">    1417</span>              :            typename _ExtractKey, typename _Equal,</span>
<span id="L1418"><span class="lineNum">    1418</span>              :            typename _Hash, typename _RangeHash, typename _Unused,</span>
<span id="L1419"><span class="lineNum">    1419</span>              :            typename _RehashPolicy, typename _Traits&gt;</span>
<span id="L1420"><span class="lineNum">    1420</span>              :     void</span>
<span id="L1421"><span class="lineNum">    1421</span>              :     _Hashtable&lt;_Key, _Value, _Alloc, _ExtractKey, _Equal,</span>
<span id="L1422"><span class="lineNum">    1422</span>              :                _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits&gt;::</span>
<span id="L1423"><span class="lineNum">    1423</span>              :     _M_move_assign(_Hashtable&amp;&amp; __ht, true_type)</span>
<span id="L1424"><span class="lineNum">    1424</span>              :     {</span>
<span id="L1425"><span class="lineNum">    1425</span>              :       if (__builtin_expect(std::__addressof(__ht) == this, false))</span>
<span id="L1426"><span class="lineNum">    1426</span>              :         return;</span>
<span id="L1427"><span class="lineNum">    1427</span>              : </span>
<span id="L1428"><span class="lineNum">    1428</span>              :       this-&gt;_M_deallocate_nodes(_M_begin());</span>
<span id="L1429"><span class="lineNum">    1429</span>              :       _M_deallocate_buckets();</span>
<span id="L1430"><span class="lineNum">    1430</span>              :       __hashtable_base::operator=(std::move(__ht));</span>
<span id="L1431"><span class="lineNum">    1431</span>              :       _M_rehash_policy = __ht._M_rehash_policy;</span>
<span id="L1432"><span class="lineNum">    1432</span>              :       if (!__ht._M_uses_single_bucket())</span>
<span id="L1433"><span class="lineNum">    1433</span>              :         _M_buckets = __ht._M_buckets;</span>
<span id="L1434"><span class="lineNum">    1434</span>              :       else</span>
<span id="L1435"><span class="lineNum">    1435</span>              :         {</span>
<span id="L1436"><span class="lineNum">    1436</span>              :           _M_buckets = &amp;_M_single_bucket;</span>
<span id="L1437"><span class="lineNum">    1437</span>              :           _M_single_bucket = __ht._M_single_bucket;</span>
<span id="L1438"><span class="lineNum">    1438</span>              :         }</span>
<span id="L1439"><span class="lineNum">    1439</span>              : </span>
<span id="L1440"><span class="lineNum">    1440</span>              :       _M_bucket_count = __ht._M_bucket_count;</span>
<span id="L1441"><span class="lineNum">    1441</span>              :       _M_before_begin._M_nxt = __ht._M_before_begin._M_nxt;</span>
<span id="L1442"><span class="lineNum">    1442</span>              :       _M_element_count = __ht._M_element_count;</span>
<span id="L1443"><span class="lineNum">    1443</span>              :       std::__alloc_on_move(this-&gt;_M_node_allocator(), __ht._M_node_allocator());</span>
<span id="L1444"><span class="lineNum">    1444</span>              : </span>
<span id="L1445"><span class="lineNum">    1445</span>              :       // Fix bucket containing the _M_before_begin pointer that can't be moved.</span>
<span id="L1446"><span class="lineNum">    1446</span>              :       _M_update_bbegin();</span>
<span id="L1447"><span class="lineNum">    1447</span>              :       __ht._M_reset();</span>
<span id="L1448"><span class="lineNum">    1448</span>              :     }</span>
<span id="L1449"><span class="lineNum">    1449</span>              : </span>
<span id="L1450"><span class="lineNum">    1450</span>              :   template&lt;typename _Key, typename _Value, typename _Alloc,</span>
<span id="L1451"><span class="lineNum">    1451</span>              :            typename _ExtractKey, typename _Equal,</span>
<span id="L1452"><span class="lineNum">    1452</span>              :            typename _Hash, typename _RangeHash, typename _Unused,</span>
<span id="L1453"><span class="lineNum">    1453</span>              :            typename _RehashPolicy, typename _Traits&gt;</span>
<span id="L1454"><span class="lineNum">    1454</span>              :     void</span>
<span id="L1455"><span class="lineNum">    1455</span>              :     _Hashtable&lt;_Key, _Value, _Alloc, _ExtractKey, _Equal,</span>
<span id="L1456"><span class="lineNum">    1456</span>              :                _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits&gt;::</span>
<span id="L1457"><span class="lineNum">    1457</span>              :     _M_move_assign(_Hashtable&amp;&amp; __ht, false_type)</span>
<span id="L1458"><span class="lineNum">    1458</span>              :     {</span>
<span id="L1459"><span class="lineNum">    1459</span>              :       if (__ht._M_node_allocator() == this-&gt;_M_node_allocator())</span>
<span id="L1460"><span class="lineNum">    1460</span>              :         _M_move_assign(std::move(__ht), true_type{});</span>
<span id="L1461"><span class="lineNum">    1461</span>              :       else</span>
<span id="L1462"><span class="lineNum">    1462</span>              :         {</span>
<span id="L1463"><span class="lineNum">    1463</span>              :           // Can't move memory, move elements then.</span>
<span id="L1464"><span class="lineNum">    1464</span>              :           _M_assign_elements(std::move(__ht));</span>
<span id="L1465"><span class="lineNum">    1465</span>              :           __ht.clear();</span>
<span id="L1466"><span class="lineNum">    1466</span>              :         }</span>
<span id="L1467"><span class="lineNum">    1467</span>              :     }</span>
<span id="L1468"><span class="lineNum">    1468</span>              : </span>
<span id="L1469"><span class="lineNum">    1469</span>              :   template&lt;typename _Key, typename _Value, typename _Alloc,</span>
<span id="L1470"><span class="lineNum">    1470</span>              :            typename _ExtractKey, typename _Equal,</span>
<span id="L1471"><span class="lineNum">    1471</span>              :            typename _Hash, typename _RangeHash, typename _Unused,</span>
<span id="L1472"><span class="lineNum">    1472</span>              :            typename _RehashPolicy, typename _Traits&gt;</span>
<span id="L1473"><span class="lineNum">    1473</span>              :     _Hashtable&lt;_Key, _Value, _Alloc, _ExtractKey, _Equal,</span>
<span id="L1474"><span class="lineNum">    1474</span>              :                _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits&gt;::</span>
<span id="L1475"><span class="lineNum">    1475</span>              :     _Hashtable(const _Hashtable&amp; __ht)</span>
<span id="L1476"><span class="lineNum">    1476</span>              :     : __hashtable_base(__ht),</span>
<span id="L1477"><span class="lineNum">    1477</span>              :       __map_base(__ht),</span>
<span id="L1478"><span class="lineNum">    1478</span>              :       __rehash_base(__ht),</span>
<span id="L1479"><span class="lineNum">    1479</span>              :       __hashtable_alloc(</span>
<span id="L1480"><span class="lineNum">    1480</span>              :         __node_alloc_traits::_S_select_on_copy(__ht._M_node_allocator())),</span>
<span id="L1481"><span class="lineNum">    1481</span>              :       __enable_default_ctor(__ht),</span>
<span id="L1482"><span class="lineNum">    1482</span>              :       _M_buckets(nullptr),</span>
<span id="L1483"><span class="lineNum">    1483</span>              :       _M_bucket_count(__ht._M_bucket_count),</span>
<span id="L1484"><span class="lineNum">    1484</span>              :       _M_element_count(__ht._M_element_count),</span>
<span id="L1485"><span class="lineNum">    1485</span>              :       _M_rehash_policy(__ht._M_rehash_policy)</span>
<span id="L1486"><span class="lineNum">    1486</span>              :     {</span>
<span id="L1487"><span class="lineNum">    1487</span>              :       __alloc_node_gen_t __alloc_node_gen(*this);</span>
<span id="L1488"><span class="lineNum">    1488</span>              :       _M_assign(__ht, __alloc_node_gen);</span>
<span id="L1489"><span class="lineNum">    1489</span>              :     }</span>
<span id="L1490"><span class="lineNum">    1490</span>              : </span>
<span id="L1491"><span class="lineNum">    1491</span>              :   template&lt;typename _Key, typename _Value, typename _Alloc,</span>
<span id="L1492"><span class="lineNum">    1492</span>              :            typename _ExtractKey, typename _Equal,</span>
<span id="L1493"><span class="lineNum">    1493</span>              :            typename _Hash, typename _RangeHash, typename _Unused,</span>
<span id="L1494"><span class="lineNum">    1494</span>              :            typename _RehashPolicy, typename _Traits&gt;</span>
<span id="L1495"><span class="lineNum">    1495</span>              :     _Hashtable&lt;_Key, _Value, _Alloc, _ExtractKey, _Equal,</span>
<span id="L1496"><span class="lineNum">    1496</span>              :                _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits&gt;::</span>
<span id="L1497"><span class="lineNum">    1497</span>              :     _Hashtable(_Hashtable&amp;&amp; __ht, __node_alloc_type&amp;&amp; __a,</span>
<span id="L1498"><span class="lineNum">    1498</span>              :                true_type /* alloc always equal */)</span>
<span id="L1499"><span class="lineNum">    1499</span>              :     noexcept(_S_nothrow_move())</span>
<span id="L1500"><span class="lineNum">    1500</span>              :     : __hashtable_base(__ht),</span>
<span id="L1501"><span class="lineNum">    1501</span>              :       __map_base(__ht),</span>
<span id="L1502"><span class="lineNum">    1502</span>              :       __rehash_base(__ht),</span>
<span id="L1503"><span class="lineNum">    1503</span>              :       __hashtable_alloc(std::move(__a)),</span>
<span id="L1504"><span class="lineNum">    1504</span>              :       __enable_default_ctor(__ht),</span>
<span id="L1505"><span class="lineNum">    1505</span>              :       _M_buckets(__ht._M_buckets),</span>
<span id="L1506"><span class="lineNum">    1506</span>              :       _M_bucket_count(__ht._M_bucket_count),</span>
<span id="L1507"><span class="lineNum">    1507</span>              :       _M_before_begin(__ht._M_before_begin._M_nxt),</span>
<span id="L1508"><span class="lineNum">    1508</span>              :       _M_element_count(__ht._M_element_count),</span>
<span id="L1509"><span class="lineNum">    1509</span>              :       _M_rehash_policy(__ht._M_rehash_policy)</span>
<span id="L1510"><span class="lineNum">    1510</span>              :     {</span>
<span id="L1511"><span class="lineNum">    1511</span>              :       // Update buckets if __ht is using its single bucket.</span>
<span id="L1512"><span class="lineNum">    1512</span>              :       if (__ht._M_uses_single_bucket())</span>
<span id="L1513"><span class="lineNum">    1513</span>              :         {</span>
<span id="L1514"><span class="lineNum">    1514</span>              :           _M_buckets = &amp;_M_single_bucket;</span>
<span id="L1515"><span class="lineNum">    1515</span>              :           _M_single_bucket = __ht._M_single_bucket;</span>
<span id="L1516"><span class="lineNum">    1516</span>              :         }</span>
<span id="L1517"><span class="lineNum">    1517</span>              : </span>
<span id="L1518"><span class="lineNum">    1518</span>              :       // Fix bucket containing the _M_before_begin pointer that can't be moved.</span>
<span id="L1519"><span class="lineNum">    1519</span>              :       _M_update_bbegin();</span>
<span id="L1520"><span class="lineNum">    1520</span>              : </span>
<span id="L1521"><span class="lineNum">    1521</span>              :       __ht._M_reset();</span>
<span id="L1522"><span class="lineNum">    1522</span>              :     }</span>
<span id="L1523"><span class="lineNum">    1523</span>              : </span>
<span id="L1524"><span class="lineNum">    1524</span>              :   template&lt;typename _Key, typename _Value, typename _Alloc,</span>
<span id="L1525"><span class="lineNum">    1525</span>              :            typename _ExtractKey, typename _Equal,</span>
<span id="L1526"><span class="lineNum">    1526</span>              :            typename _Hash, typename _RangeHash, typename _Unused,</span>
<span id="L1527"><span class="lineNum">    1527</span>              :            typename _RehashPolicy, typename _Traits&gt;</span>
<span id="L1528"><span class="lineNum">    1528</span>              :     _Hashtable&lt;_Key, _Value, _Alloc, _ExtractKey, _Equal,</span>
<span id="L1529"><span class="lineNum">    1529</span>              :                _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits&gt;::</span>
<span id="L1530"><span class="lineNum">    1530</span>              :     _Hashtable(const _Hashtable&amp; __ht, const allocator_type&amp; __a)</span>
<span id="L1531"><span class="lineNum">    1531</span>              :     : __hashtable_base(__ht),</span>
<span id="L1532"><span class="lineNum">    1532</span>              :       __map_base(__ht),</span>
<span id="L1533"><span class="lineNum">    1533</span>              :       __rehash_base(__ht),</span>
<span id="L1534"><span class="lineNum">    1534</span>              :       __hashtable_alloc(__node_alloc_type(__a)),</span>
<span id="L1535"><span class="lineNum">    1535</span>              :       __enable_default_ctor(__ht),</span>
<span id="L1536"><span class="lineNum">    1536</span>              :       _M_buckets(),</span>
<span id="L1537"><span class="lineNum">    1537</span>              :       _M_bucket_count(__ht._M_bucket_count),</span>
<span id="L1538"><span class="lineNum">    1538</span>              :       _M_element_count(__ht._M_element_count),</span>
<span id="L1539"><span class="lineNum">    1539</span>              :       _M_rehash_policy(__ht._M_rehash_policy)</span>
<span id="L1540"><span class="lineNum">    1540</span>              :     {</span>
<span id="L1541"><span class="lineNum">    1541</span>              :       __alloc_node_gen_t __alloc_node_gen(*this);</span>
<span id="L1542"><span class="lineNum">    1542</span>              :       _M_assign(__ht, __alloc_node_gen);</span>
<span id="L1543"><span class="lineNum">    1543</span>              :     }</span>
<span id="L1544"><span class="lineNum">    1544</span>              : </span>
<span id="L1545"><span class="lineNum">    1545</span>              :   template&lt;typename _Key, typename _Value, typename _Alloc,</span>
<span id="L1546"><span class="lineNum">    1546</span>              :            typename _ExtractKey, typename _Equal,</span>
<span id="L1547"><span class="lineNum">    1547</span>              :            typename _Hash, typename _RangeHash, typename _Unused,</span>
<span id="L1548"><span class="lineNum">    1548</span>              :            typename _RehashPolicy, typename _Traits&gt;</span>
<span id="L1549"><span class="lineNum">    1549</span>              :     _Hashtable&lt;_Key, _Value, _Alloc, _ExtractKey, _Equal,</span>
<span id="L1550"><span class="lineNum">    1550</span>              :                _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits&gt;::</span>
<span id="L1551"><span class="lineNum">    1551</span>              :     _Hashtable(_Hashtable&amp;&amp; __ht, __node_alloc_type&amp;&amp; __a,</span>
<span id="L1552"><span class="lineNum">    1552</span>              :                false_type /* alloc always equal */)</span>
<span id="L1553"><span class="lineNum">    1553</span>              :     : __hashtable_base(__ht),</span>
<span id="L1554"><span class="lineNum">    1554</span>              :       __map_base(__ht),</span>
<span id="L1555"><span class="lineNum">    1555</span>              :       __rehash_base(__ht),</span>
<span id="L1556"><span class="lineNum">    1556</span>              :       __hashtable_alloc(std::move(__a)),</span>
<span id="L1557"><span class="lineNum">    1557</span>              :       __enable_default_ctor(__ht),</span>
<span id="L1558"><span class="lineNum">    1558</span>              :       _M_buckets(nullptr),</span>
<span id="L1559"><span class="lineNum">    1559</span>              :       _M_bucket_count(__ht._M_bucket_count),</span>
<span id="L1560"><span class="lineNum">    1560</span>              :       _M_element_count(__ht._M_element_count),</span>
<span id="L1561"><span class="lineNum">    1561</span>              :       _M_rehash_policy(__ht._M_rehash_policy)</span>
<span id="L1562"><span class="lineNum">    1562</span>              :     {</span>
<span id="L1563"><span class="lineNum">    1563</span>              :       if (__ht._M_node_allocator() == this-&gt;_M_node_allocator())</span>
<span id="L1564"><span class="lineNum">    1564</span>              :         {</span>
<span id="L1565"><span class="lineNum">    1565</span>              :           if (__ht._M_uses_single_bucket())</span>
<span id="L1566"><span class="lineNum">    1566</span>              :             {</span>
<span id="L1567"><span class="lineNum">    1567</span>              :               _M_buckets = &amp;_M_single_bucket;</span>
<span id="L1568"><span class="lineNum">    1568</span>              :               _M_single_bucket = __ht._M_single_bucket;</span>
<span id="L1569"><span class="lineNum">    1569</span>              :             }</span>
<span id="L1570"><span class="lineNum">    1570</span>              :           else</span>
<span id="L1571"><span class="lineNum">    1571</span>              :             _M_buckets = __ht._M_buckets;</span>
<span id="L1572"><span class="lineNum">    1572</span>              : </span>
<span id="L1573"><span class="lineNum">    1573</span>              :           // Fix bucket containing the _M_before_begin pointer that can't be</span>
<span id="L1574"><span class="lineNum">    1574</span>              :           // moved.</span>
<span id="L1575"><span class="lineNum">    1575</span>              :           _M_update_bbegin(__ht._M_begin());</span>
<span id="L1576"><span class="lineNum">    1576</span>              : </span>
<span id="L1577"><span class="lineNum">    1577</span>              :           __ht._M_reset();</span>
<span id="L1578"><span class="lineNum">    1578</span>              :         }</span>
<span id="L1579"><span class="lineNum">    1579</span>              :       else</span>
<span id="L1580"><span class="lineNum">    1580</span>              :         {</span>
<span id="L1581"><span class="lineNum">    1581</span>              :           __alloc_node_gen_t __alloc_gen(*this);</span>
<span id="L1582"><span class="lineNum">    1582</span>              : </span>
<span id="L1583"><span class="lineNum">    1583</span>              :           using _Fwd_Ht = __conditional_t&lt;</span>
<span id="L1584"><span class="lineNum">    1584</span>              :             __move_if_noexcept_cond&lt;value_type&gt;::value,</span>
<span id="L1585"><span class="lineNum">    1585</span>              :             const _Hashtable&amp;, _Hashtable&amp;&amp;&gt;;</span>
<span id="L1586"><span class="lineNum">    1586</span>              :           _M_assign(std::forward&lt;_Fwd_Ht&gt;(__ht), __alloc_gen);</span>
<span id="L1587"><span class="lineNum">    1587</span>              :           __ht.clear();</span>
<span id="L1588"><span class="lineNum">    1588</span>              :         }</span>
<span id="L1589"><span class="lineNum">    1589</span>              :     }</span>
<span id="L1590"><span class="lineNum">    1590</span>              : </span>
<span id="L1591"><span class="lineNum">    1591</span>              :   template&lt;typename _Key, typename _Value, typename _Alloc,</span>
<span id="L1592"><span class="lineNum">    1592</span>              :            typename _ExtractKey, typename _Equal,</span>
<span id="L1593"><span class="lineNum">    1593</span>              :            typename _Hash, typename _RangeHash, typename _Unused,</span>
<span id="L1594"><span class="lineNum">    1594</span>              :            typename _RehashPolicy, typename _Traits&gt;</span>
<span id="L1595"><span class="lineNum">    1595</span> <span class="tlaGNC tlaBgGNC">           2 :     _Hashtable&lt;_Key, _Value, _Alloc, _ExtractKey, _Equal,</span></span>
<span id="L1596"><span class="lineNum">    1596</span>              :                _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits&gt;::</span>
<span id="L1597"><span class="lineNum">    1597</span>              :     ~_Hashtable() noexcept</span>
<span id="L1598"><span class="lineNum">    1598</span>              :     {</span>
<span id="L1599"><span class="lineNum">    1599</span>              :       // Getting a bucket index from a node shall not throw because it is used</span>
<span id="L1600"><span class="lineNum">    1600</span>              :       // in methods (erase, swap...) that shall not throw. Need a complete</span>
<span id="L1601"><span class="lineNum">    1601</span>              :       // type to check this, so do it in the destructor not at class scope.</span>
<span id="L1602"><span class="lineNum">    1602</span>              :       static_assert(noexcept(declval&lt;const __hash_code_base_access&amp;&gt;()</span>
<span id="L1603"><span class="lineNum">    1603</span>              :                         ._M_bucket_index(declval&lt;const __node_value_type&amp;&gt;(),</span>
<span id="L1604"><span class="lineNum">    1604</span>              :                                          (std::size_t)0)),</span>
<span id="L1605"><span class="lineNum">    1605</span>              :                     &quot;Cache the hash code or qualify your functors involved&quot;</span>
<span id="L1606"><span class="lineNum">    1606</span>              :                     &quot; in hash code and bucket index computation with noexcept&quot;);</span>
<span id="L1607"><span class="lineNum">    1607</span>              : </span>
<span id="L1608"><span class="lineNum">    1608</span> <span class="tlaGNC">           2 :       clear();</span></span>
<span id="L1609"><span class="lineNum">    1609</span> <span class="tlaGNC">           2 :       _M_deallocate_buckets();</span></span>
<span id="L1610"><span class="lineNum">    1610</span> <span class="tlaGNC">           2 :     }</span></span>
<span id="L1611"><span class="lineNum">    1611</span>              : </span>
<span id="L1612"><span class="lineNum">    1612</span>              :   template&lt;typename _Key, typename _Value, typename _Alloc,</span>
<span id="L1613"><span class="lineNum">    1613</span>              :            typename _ExtractKey, typename _Equal,</span>
<span id="L1614"><span class="lineNum">    1614</span>              :            typename _Hash, typename _RangeHash, typename _Unused,</span>
<span id="L1615"><span class="lineNum">    1615</span>              :            typename _RehashPolicy, typename _Traits&gt;</span>
<span id="L1616"><span class="lineNum">    1616</span>              :     void</span>
<span id="L1617"><span class="lineNum">    1617</span>              :     _Hashtable&lt;_Key, _Value, _Alloc, _ExtractKey, _Equal,</span>
<span id="L1618"><span class="lineNum">    1618</span>              :                _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits&gt;::</span>
<span id="L1619"><span class="lineNum">    1619</span>              :     swap(_Hashtable&amp; __x)</span>
<span id="L1620"><span class="lineNum">    1620</span>              :     noexcept(__and_&lt;__is_nothrow_swappable&lt;_Hash&gt;,</span>
<span id="L1621"><span class="lineNum">    1621</span>              :                         __is_nothrow_swappable&lt;_Equal&gt;&gt;::value)</span>
<span id="L1622"><span class="lineNum">    1622</span>              :     {</span>
<span id="L1623"><span class="lineNum">    1623</span>              :       // The only base class with member variables is hash_code_base.</span>
<span id="L1624"><span class="lineNum">    1624</span>              :       // We define _Hash_code_base::_M_swap because different</span>
<span id="L1625"><span class="lineNum">    1625</span>              :       // specializations have different members.</span>
<span id="L1626"><span class="lineNum">    1626</span>              :       this-&gt;_M_swap(__x);</span>
<span id="L1627"><span class="lineNum">    1627</span>              : </span>
<span id="L1628"><span class="lineNum">    1628</span>              :       std::__alloc_on_swap(this-&gt;_M_node_allocator(), __x._M_node_allocator());</span>
<span id="L1629"><span class="lineNum">    1629</span>              :       std::swap(_M_rehash_policy, __x._M_rehash_policy);</span>
<span id="L1630"><span class="lineNum">    1630</span>              : </span>
<span id="L1631"><span class="lineNum">    1631</span>              :       // Deal properly with potentially moved instances.</span>
<span id="L1632"><span class="lineNum">    1632</span>              :       if (this-&gt;_M_uses_single_bucket())</span>
<span id="L1633"><span class="lineNum">    1633</span>              :         {</span>
<span id="L1634"><span class="lineNum">    1634</span>              :           if (!__x._M_uses_single_bucket())</span>
<span id="L1635"><span class="lineNum">    1635</span>              :             {</span>
<span id="L1636"><span class="lineNum">    1636</span>              :               _M_buckets = __x._M_buckets;</span>
<span id="L1637"><span class="lineNum">    1637</span>              :               __x._M_buckets = &amp;__x._M_single_bucket;</span>
<span id="L1638"><span class="lineNum">    1638</span>              :             }</span>
<span id="L1639"><span class="lineNum">    1639</span>              :         }</span>
<span id="L1640"><span class="lineNum">    1640</span>              :       else if (__x._M_uses_single_bucket())</span>
<span id="L1641"><span class="lineNum">    1641</span>              :         {</span>
<span id="L1642"><span class="lineNum">    1642</span>              :           __x._M_buckets = _M_buckets;</span>
<span id="L1643"><span class="lineNum">    1643</span>              :           _M_buckets = &amp;_M_single_bucket;</span>
<span id="L1644"><span class="lineNum">    1644</span>              :         }       </span>
<span id="L1645"><span class="lineNum">    1645</span>              :       else</span>
<span id="L1646"><span class="lineNum">    1646</span>              :         std::swap(_M_buckets, __x._M_buckets);</span>
<span id="L1647"><span class="lineNum">    1647</span>              : </span>
<span id="L1648"><span class="lineNum">    1648</span>              :       std::swap(_M_bucket_count, __x._M_bucket_count);</span>
<span id="L1649"><span class="lineNum">    1649</span>              :       std::swap(_M_before_begin._M_nxt, __x._M_before_begin._M_nxt);</span>
<span id="L1650"><span class="lineNum">    1650</span>              :       std::swap(_M_element_count, __x._M_element_count);</span>
<span id="L1651"><span class="lineNum">    1651</span>              :       std::swap(_M_single_bucket, __x._M_single_bucket);</span>
<span id="L1652"><span class="lineNum">    1652</span>              : </span>
<span id="L1653"><span class="lineNum">    1653</span>              :       // Fix buckets containing the _M_before_begin pointers that can't be</span>
<span id="L1654"><span class="lineNum">    1654</span>              :       // swapped.</span>
<span id="L1655"><span class="lineNum">    1655</span>              :       _M_update_bbegin();</span>
<span id="L1656"><span class="lineNum">    1656</span>              :       __x._M_update_bbegin();</span>
<span id="L1657"><span class="lineNum">    1657</span>              :     }</span>
<span id="L1658"><span class="lineNum">    1658</span>              : </span>
<span id="L1659"><span class="lineNum">    1659</span>              :   template&lt;typename _Key, typename _Value, typename _Alloc,</span>
<span id="L1660"><span class="lineNum">    1660</span>              :            typename _ExtractKey, typename _Equal,</span>
<span id="L1661"><span class="lineNum">    1661</span>              :            typename _Hash, typename _RangeHash, typename _Unused,</span>
<span id="L1662"><span class="lineNum">    1662</span>              :            typename _RehashPolicy, typename _Traits&gt;</span>
<span id="L1663"><span class="lineNum">    1663</span>              :     auto</span>
<span id="L1664"><span class="lineNum">    1664</span> <span class="tlaGNC">           7 :     _Hashtable&lt;_Key, _Value, _Alloc, _ExtractKey, _Equal,</span></span>
<span id="L1665"><span class="lineNum">    1665</span>              :                _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits&gt;::</span>
<span id="L1666"><span class="lineNum">    1666</span>              :     find(const key_type&amp; __k)</span>
<span id="L1667"><span class="lineNum">    1667</span>              :     -&gt; iterator</span>
<span id="L1668"><span class="lineNum">    1668</span>              :     {</span>
<span id="L1669"><span class="lineNum">    1669</span> <span class="tlaGNC">           7 :       if (size() &lt;= __small_size_threshold())</span></span>
<span id="L1670"><span class="lineNum">    1670</span>              :         {</span>
<span id="L1671"><span class="lineNum">    1671</span> <span class="tlaGNC">          12 :           for (auto __it = begin(); __it != end(); ++__it)</span></span>
<span id="L1672"><span class="lineNum">    1672</span> <span class="tlaGNC">           7 :             if (this-&gt;_M_key_equals(__k, *__it._M_cur))</span></span>
<span id="L1673"><span class="lineNum">    1673</span> <span class="tlaGNC">           2 :               return __it;</span></span>
<span id="L1674"><span class="lineNum">    1674</span> <span class="tlaGNC">           5 :           return end();</span></span>
<span id="L1675"><span class="lineNum">    1675</span>              :         }</span>
<span id="L1676"><span class="lineNum">    1676</span>              : </span>
<span id="L1677"><span class="lineNum">    1677</span> <span class="tlaUNC tlaBgUNC">           0 :       __hash_code __code = this-&gt;_M_hash_code(__k);</span></span>
<span id="L1678"><span class="lineNum">    1678</span> <span class="tlaUNC">           0 :       std::size_t __bkt = _M_bucket_index(__code);</span></span>
<span id="L1679"><span class="lineNum">    1679</span> <span class="tlaUNC">           0 :       return iterator(_M_find_node(__bkt, __k, __code));</span></span>
<span id="L1680"><span class="lineNum">    1680</span>              :     }</span>
<span id="L1681"><span class="lineNum">    1681</span>              : </span>
<span id="L1682"><span class="lineNum">    1682</span>              :   template&lt;typename _Key, typename _Value, typename _Alloc,</span>
<span id="L1683"><span class="lineNum">    1683</span>              :            typename _ExtractKey, typename _Equal,</span>
<span id="L1684"><span class="lineNum">    1684</span>              :            typename _Hash, typename _RangeHash, typename _Unused,</span>
<span id="L1685"><span class="lineNum">    1685</span>              :            typename _RehashPolicy, typename _Traits&gt;</span>
<span id="L1686"><span class="lineNum">    1686</span>              :     auto</span>
<span id="L1687"><span class="lineNum">    1687</span>              :     _Hashtable&lt;_Key, _Value, _Alloc, _ExtractKey, _Equal,</span>
<span id="L1688"><span class="lineNum">    1688</span>              :                _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits&gt;::</span>
<span id="L1689"><span class="lineNum">    1689</span>              :     find(const key_type&amp; __k) const</span>
<span id="L1690"><span class="lineNum">    1690</span>              :     -&gt; const_iterator</span>
<span id="L1691"><span class="lineNum">    1691</span>              :     {</span>
<span id="L1692"><span class="lineNum">    1692</span>              :       if (size() &lt;= __small_size_threshold())</span>
<span id="L1693"><span class="lineNum">    1693</span>              :         {</span>
<span id="L1694"><span class="lineNum">    1694</span>              :           for (auto __it = begin(); __it != end(); ++__it)</span>
<span id="L1695"><span class="lineNum">    1695</span>              :             if (this-&gt;_M_key_equals(__k, *__it._M_cur))</span>
<span id="L1696"><span class="lineNum">    1696</span>              :               return __it;</span>
<span id="L1697"><span class="lineNum">    1697</span>              :           return end();</span>
<span id="L1698"><span class="lineNum">    1698</span>              :         }</span>
<span id="L1699"><span class="lineNum">    1699</span>              : </span>
<span id="L1700"><span class="lineNum">    1700</span>              :       __hash_code __code = this-&gt;_M_hash_code(__k);</span>
<span id="L1701"><span class="lineNum">    1701</span>              :       std::size_t __bkt = _M_bucket_index(__code);</span>
<span id="L1702"><span class="lineNum">    1702</span>              :       return const_iterator(_M_find_node(__bkt, __k, __code));</span>
<span id="L1703"><span class="lineNum">    1703</span>              :     }</span>
<span id="L1704"><span class="lineNum">    1704</span>              : </span>
<span id="L1705"><span class="lineNum">    1705</span>              : #if __cplusplus &gt; 201703L</span>
<span id="L1706"><span class="lineNum">    1706</span>              :   template&lt;typename _Key, typename _Value, typename _Alloc,</span>
<span id="L1707"><span class="lineNum">    1707</span>              :            typename _ExtractKey, typename _Equal,</span>
<span id="L1708"><span class="lineNum">    1708</span>              :            typename _Hash, typename _RangeHash, typename _Unused,</span>
<span id="L1709"><span class="lineNum">    1709</span>              :            typename _RehashPolicy, typename _Traits&gt;</span>
<span id="L1710"><span class="lineNum">    1710</span>              :     template&lt;typename _Kt, typename, typename&gt;</span>
<span id="L1711"><span class="lineNum">    1711</span>              :       auto</span>
<span id="L1712"><span class="lineNum">    1712</span>              :       _Hashtable&lt;_Key, _Value, _Alloc, _ExtractKey, _Equal,</span>
<span id="L1713"><span class="lineNum">    1713</span>              :                  _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits&gt;::</span>
<span id="L1714"><span class="lineNum">    1714</span>              :       _M_find_tr(const _Kt&amp; __k)</span>
<span id="L1715"><span class="lineNum">    1715</span>              :       -&gt; iterator</span>
<span id="L1716"><span class="lineNum">    1716</span>              :       {</span>
<span id="L1717"><span class="lineNum">    1717</span>              :         __hash_code __code = this-&gt;_M_hash_code_tr(__k);</span>
<span id="L1718"><span class="lineNum">    1718</span>              :         std::size_t __bkt = _M_bucket_index(__code);</span>
<span id="L1719"><span class="lineNum">    1719</span>              :         return iterator(_M_find_node_tr(__bkt, __k, __code));</span>
<span id="L1720"><span class="lineNum">    1720</span>              :       }</span>
<span id="L1721"><span class="lineNum">    1721</span>              : </span>
<span id="L1722"><span class="lineNum">    1722</span>              :   template&lt;typename _Key, typename _Value, typename _Alloc,</span>
<span id="L1723"><span class="lineNum">    1723</span>              :            typename _ExtractKey, typename _Equal,</span>
<span id="L1724"><span class="lineNum">    1724</span>              :            typename _Hash, typename _RangeHash, typename _Unused,</span>
<span id="L1725"><span class="lineNum">    1725</span>              :            typename _RehashPolicy, typename _Traits&gt;</span>
<span id="L1726"><span class="lineNum">    1726</span>              :     template&lt;typename _Kt, typename, typename&gt;</span>
<span id="L1727"><span class="lineNum">    1727</span>              :       auto</span>
<span id="L1728"><span class="lineNum">    1728</span>              :       _Hashtable&lt;_Key, _Value, _Alloc, _ExtractKey, _Equal,</span>
<span id="L1729"><span class="lineNum">    1729</span>              :                  _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits&gt;::</span>
<span id="L1730"><span class="lineNum">    1730</span>              :       _M_find_tr(const _Kt&amp; __k) const</span>
<span id="L1731"><span class="lineNum">    1731</span>              :       -&gt; const_iterator</span>
<span id="L1732"><span class="lineNum">    1732</span>              :       {</span>
<span id="L1733"><span class="lineNum">    1733</span>              :         __hash_code __code = this-&gt;_M_hash_code_tr(__k);</span>
<span id="L1734"><span class="lineNum">    1734</span>              :         std::size_t __bkt = _M_bucket_index(__code);</span>
<span id="L1735"><span class="lineNum">    1735</span>              :         return const_iterator(_M_find_node_tr(__bkt, __k, __code));</span>
<span id="L1736"><span class="lineNum">    1736</span>              :       }</span>
<span id="L1737"><span class="lineNum">    1737</span>              : #endif</span>
<span id="L1738"><span class="lineNum">    1738</span>              : </span>
<span id="L1739"><span class="lineNum">    1739</span>              :   template&lt;typename _Key, typename _Value, typename _Alloc,</span>
<span id="L1740"><span class="lineNum">    1740</span>              :            typename _ExtractKey, typename _Equal,</span>
<span id="L1741"><span class="lineNum">    1741</span>              :            typename _Hash, typename _RangeHash, typename _Unused,</span>
<span id="L1742"><span class="lineNum">    1742</span>              :            typename _RehashPolicy, typename _Traits&gt;</span>
<span id="L1743"><span class="lineNum">    1743</span>              :     auto</span>
<span id="L1744"><span class="lineNum">    1744</span>              :     _Hashtable&lt;_Key, _Value, _Alloc, _ExtractKey, _Equal,</span>
<span id="L1745"><span class="lineNum">    1745</span>              :                _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits&gt;::</span>
<span id="L1746"><span class="lineNum">    1746</span>              :     count(const key_type&amp; __k) const</span>
<span id="L1747"><span class="lineNum">    1747</span>              :     -&gt; size_type</span>
<span id="L1748"><span class="lineNum">    1748</span>              :     {</span>
<span id="L1749"><span class="lineNum">    1749</span>              :       auto __it = find(__k);</span>
<span id="L1750"><span class="lineNum">    1750</span>              :       if (!__it._M_cur)</span>
<span id="L1751"><span class="lineNum">    1751</span>              :         return 0;</span>
<span id="L1752"><span class="lineNum">    1752</span>              : </span>
<span id="L1753"><span class="lineNum">    1753</span>              :       if (__unique_keys::value)</span>
<span id="L1754"><span class="lineNum">    1754</span>              :         return 1;</span>
<span id="L1755"><span class="lineNum">    1755</span>              : </span>
<span id="L1756"><span class="lineNum">    1756</span>              :       // All equivalent values are next to each other, if we find a</span>
<span id="L1757"><span class="lineNum">    1757</span>              :       // non-equivalent value after an equivalent one it means that we won't</span>
<span id="L1758"><span class="lineNum">    1758</span>              :       // find any new equivalent value.</span>
<span id="L1759"><span class="lineNum">    1759</span>              :       size_type __result = 1;</span>
<span id="L1760"><span class="lineNum">    1760</span>              :       for (auto __ref = __it++;</span>
<span id="L1761"><span class="lineNum">    1761</span>              :            __it._M_cur &amp;&amp; this-&gt;_M_node_equals(*__ref._M_cur, *__it._M_cur);</span>
<span id="L1762"><span class="lineNum">    1762</span>              :            ++__it)</span>
<span id="L1763"><span class="lineNum">    1763</span>              :         ++__result;</span>
<span id="L1764"><span class="lineNum">    1764</span>              : </span>
<span id="L1765"><span class="lineNum">    1765</span>              :       return __result;</span>
<span id="L1766"><span class="lineNum">    1766</span>              :     }</span>
<span id="L1767"><span class="lineNum">    1767</span>              : </span>
<span id="L1768"><span class="lineNum">    1768</span>              : #if __cplusplus &gt; 201703L</span>
<span id="L1769"><span class="lineNum">    1769</span>              :   template&lt;typename _Key, typename _Value, typename _Alloc,</span>
<span id="L1770"><span class="lineNum">    1770</span>              :            typename _ExtractKey, typename _Equal,</span>
<span id="L1771"><span class="lineNum">    1771</span>              :            typename _Hash, typename _RangeHash, typename _Unused,</span>
<span id="L1772"><span class="lineNum">    1772</span>              :            typename _RehashPolicy, typename _Traits&gt;</span>
<span id="L1773"><span class="lineNum">    1773</span>              :     template&lt;typename _Kt, typename, typename&gt;</span>
<span id="L1774"><span class="lineNum">    1774</span>              :       auto</span>
<span id="L1775"><span class="lineNum">    1775</span>              :       _Hashtable&lt;_Key, _Value, _Alloc, _ExtractKey, _Equal,</span>
<span id="L1776"><span class="lineNum">    1776</span>              :                  _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits&gt;::</span>
<span id="L1777"><span class="lineNum">    1777</span>              :       _M_count_tr(const _Kt&amp; __k) const</span>
<span id="L1778"><span class="lineNum">    1778</span>              :       -&gt; size_type</span>
<span id="L1779"><span class="lineNum">    1779</span>              :       {</span>
<span id="L1780"><span class="lineNum">    1780</span>              :         __hash_code __code = this-&gt;_M_hash_code_tr(__k);</span>
<span id="L1781"><span class="lineNum">    1781</span>              :         std::size_t __bkt = _M_bucket_index(__code);</span>
<span id="L1782"><span class="lineNum">    1782</span>              :         auto __n = _M_find_node_tr(__bkt, __k, __code);</span>
<span id="L1783"><span class="lineNum">    1783</span>              :         if (!__n)</span>
<span id="L1784"><span class="lineNum">    1784</span>              :           return 0;</span>
<span id="L1785"><span class="lineNum">    1785</span>              : </span>
<span id="L1786"><span class="lineNum">    1786</span>              :         // All equivalent values are next to each other, if we find a</span>
<span id="L1787"><span class="lineNum">    1787</span>              :         // non-equivalent value after an equivalent one it means that we won't</span>
<span id="L1788"><span class="lineNum">    1788</span>              :         // find any new equivalent value.</span>
<span id="L1789"><span class="lineNum">    1789</span>              :         iterator __it(__n);</span>
<span id="L1790"><span class="lineNum">    1790</span>              :         size_type __result = 1;</span>
<span id="L1791"><span class="lineNum">    1791</span>              :         for (++__it;</span>
<span id="L1792"><span class="lineNum">    1792</span>              :              __it._M_cur &amp;&amp; this-&gt;_M_equals_tr(__k, __code, *__it._M_cur);</span>
<span id="L1793"><span class="lineNum">    1793</span>              :              ++__it)</span>
<span id="L1794"><span class="lineNum">    1794</span>              :           ++__result;</span>
<span id="L1795"><span class="lineNum">    1795</span>              : </span>
<span id="L1796"><span class="lineNum">    1796</span>              :         return __result;</span>
<span id="L1797"><span class="lineNum">    1797</span>              :       }</span>
<span id="L1798"><span class="lineNum">    1798</span>              : #endif</span>
<span id="L1799"><span class="lineNum">    1799</span>              : </span>
<span id="L1800"><span class="lineNum">    1800</span>              :   template&lt;typename _Key, typename _Value, typename _Alloc,</span>
<span id="L1801"><span class="lineNum">    1801</span>              :            typename _ExtractKey, typename _Equal,</span>
<span id="L1802"><span class="lineNum">    1802</span>              :            typename _Hash, typename _RangeHash, typename _Unused,</span>
<span id="L1803"><span class="lineNum">    1803</span>              :            typename _RehashPolicy, typename _Traits&gt;</span>
<span id="L1804"><span class="lineNum">    1804</span>              :     auto</span>
<span id="L1805"><span class="lineNum">    1805</span>              :     _Hashtable&lt;_Key, _Value, _Alloc, _ExtractKey, _Equal,</span>
<span id="L1806"><span class="lineNum">    1806</span>              :                _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits&gt;::</span>
<span id="L1807"><span class="lineNum">    1807</span>              :     equal_range(const key_type&amp; __k)</span>
<span id="L1808"><span class="lineNum">    1808</span>              :     -&gt; pair&lt;iterator, iterator&gt;</span>
<span id="L1809"><span class="lineNum">    1809</span>              :     {</span>
<span id="L1810"><span class="lineNum">    1810</span>              :       auto __ite = find(__k);</span>
<span id="L1811"><span class="lineNum">    1811</span>              :       if (!__ite._M_cur)</span>
<span id="L1812"><span class="lineNum">    1812</span>              :         return { __ite, __ite };</span>
<span id="L1813"><span class="lineNum">    1813</span>              : </span>
<span id="L1814"><span class="lineNum">    1814</span>              :       auto __beg = __ite++;</span>
<span id="L1815"><span class="lineNum">    1815</span>              :       if (__unique_keys::value)</span>
<span id="L1816"><span class="lineNum">    1816</span>              :         return { __beg, __ite };</span>
<span id="L1817"><span class="lineNum">    1817</span>              : </span>
<span id="L1818"><span class="lineNum">    1818</span>              :       // All equivalent values are next to each other, if we find a</span>
<span id="L1819"><span class="lineNum">    1819</span>              :       // non-equivalent value after an equivalent one it means that we won't</span>
<span id="L1820"><span class="lineNum">    1820</span>              :       // find any new equivalent value.</span>
<span id="L1821"><span class="lineNum">    1821</span>              :       while (__ite._M_cur &amp;&amp; this-&gt;_M_node_equals(*__beg._M_cur, *__ite._M_cur))</span>
<span id="L1822"><span class="lineNum">    1822</span>              :         ++__ite;</span>
<span id="L1823"><span class="lineNum">    1823</span>              : </span>
<span id="L1824"><span class="lineNum">    1824</span>              :       return { __beg, __ite };</span>
<span id="L1825"><span class="lineNum">    1825</span>              :     }</span>
<span id="L1826"><span class="lineNum">    1826</span>              : </span>
<span id="L1827"><span class="lineNum">    1827</span>              :   template&lt;typename _Key, typename _Value, typename _Alloc,</span>
<span id="L1828"><span class="lineNum">    1828</span>              :            typename _ExtractKey, typename _Equal,</span>
<span id="L1829"><span class="lineNum">    1829</span>              :            typename _Hash, typename _RangeHash, typename _Unused,</span>
<span id="L1830"><span class="lineNum">    1830</span>              :            typename _RehashPolicy, typename _Traits&gt;</span>
<span id="L1831"><span class="lineNum">    1831</span>              :     auto</span>
<span id="L1832"><span class="lineNum">    1832</span>              :     _Hashtable&lt;_Key, _Value, _Alloc, _ExtractKey, _Equal,</span>
<span id="L1833"><span class="lineNum">    1833</span>              :                _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits&gt;::</span>
<span id="L1834"><span class="lineNum">    1834</span>              :     equal_range(const key_type&amp; __k) const</span>
<span id="L1835"><span class="lineNum">    1835</span>              :     -&gt; pair&lt;const_iterator, const_iterator&gt;</span>
<span id="L1836"><span class="lineNum">    1836</span>              :     {</span>
<span id="L1837"><span class="lineNum">    1837</span>              :       auto __ite = find(__k);</span>
<span id="L1838"><span class="lineNum">    1838</span>              :       if (!__ite._M_cur)</span>
<span id="L1839"><span class="lineNum">    1839</span>              :         return { __ite, __ite };</span>
<span id="L1840"><span class="lineNum">    1840</span>              : </span>
<span id="L1841"><span class="lineNum">    1841</span>              :       auto __beg = __ite++;</span>
<span id="L1842"><span class="lineNum">    1842</span>              :       if (__unique_keys::value)</span>
<span id="L1843"><span class="lineNum">    1843</span>              :         return { __beg, __ite };</span>
<span id="L1844"><span class="lineNum">    1844</span>              : </span>
<span id="L1845"><span class="lineNum">    1845</span>              :       // All equivalent values are next to each other, if we find a</span>
<span id="L1846"><span class="lineNum">    1846</span>              :       // non-equivalent value after an equivalent one it means that we won't</span>
<span id="L1847"><span class="lineNum">    1847</span>              :       // find any new equivalent value.</span>
<span id="L1848"><span class="lineNum">    1848</span>              :       while (__ite._M_cur &amp;&amp; this-&gt;_M_node_equals(*__beg._M_cur, *__ite._M_cur))</span>
<span id="L1849"><span class="lineNum">    1849</span>              :         ++__ite;</span>
<span id="L1850"><span class="lineNum">    1850</span>              : </span>
<span id="L1851"><span class="lineNum">    1851</span>              :       return { __beg, __ite };</span>
<span id="L1852"><span class="lineNum">    1852</span>              :     }</span>
<span id="L1853"><span class="lineNum">    1853</span>              : </span>
<span id="L1854"><span class="lineNum">    1854</span>              : #if __cplusplus &gt; 201703L</span>
<span id="L1855"><span class="lineNum">    1855</span>              :   template&lt;typename _Key, typename _Value, typename _Alloc,</span>
<span id="L1856"><span class="lineNum">    1856</span>              :            typename _ExtractKey, typename _Equal,</span>
<span id="L1857"><span class="lineNum">    1857</span>              :            typename _Hash, typename _RangeHash, typename _Unused,</span>
<span id="L1858"><span class="lineNum">    1858</span>              :            typename _RehashPolicy, typename _Traits&gt;</span>
<span id="L1859"><span class="lineNum">    1859</span>              :     template&lt;typename _Kt, typename, typename&gt;</span>
<span id="L1860"><span class="lineNum">    1860</span>              :       auto</span>
<span id="L1861"><span class="lineNum">    1861</span>              :       _Hashtable&lt;_Key, _Value, _Alloc, _ExtractKey, _Equal,</span>
<span id="L1862"><span class="lineNum">    1862</span>              :                  _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits&gt;::</span>
<span id="L1863"><span class="lineNum">    1863</span>              :       _M_equal_range_tr(const _Kt&amp; __k)</span>
<span id="L1864"><span class="lineNum">    1864</span>              :       -&gt; pair&lt;iterator, iterator&gt;</span>
<span id="L1865"><span class="lineNum">    1865</span>              :       {</span>
<span id="L1866"><span class="lineNum">    1866</span>              :         __hash_code __code = this-&gt;_M_hash_code_tr(__k);</span>
<span id="L1867"><span class="lineNum">    1867</span>              :         std::size_t __bkt = _M_bucket_index(__code);</span>
<span id="L1868"><span class="lineNum">    1868</span>              :         auto __n = _M_find_node_tr(__bkt, __k, __code);</span>
<span id="L1869"><span class="lineNum">    1869</span>              :         iterator __ite(__n);</span>
<span id="L1870"><span class="lineNum">    1870</span>              :         if (!__n)</span>
<span id="L1871"><span class="lineNum">    1871</span>              :           return { __ite, __ite };</span>
<span id="L1872"><span class="lineNum">    1872</span>              : </span>
<span id="L1873"><span class="lineNum">    1873</span>              :         // All equivalent values are next to each other, if we find a</span>
<span id="L1874"><span class="lineNum">    1874</span>              :         // non-equivalent value after an equivalent one it means that we won't</span>
<span id="L1875"><span class="lineNum">    1875</span>              :         // find any new equivalent value.</span>
<span id="L1876"><span class="lineNum">    1876</span>              :         auto __beg = __ite++;</span>
<span id="L1877"><span class="lineNum">    1877</span>              :         while (__ite._M_cur &amp;&amp; this-&gt;_M_equals_tr(__k, __code, *__ite._M_cur))</span>
<span id="L1878"><span class="lineNum">    1878</span>              :           ++__ite;</span>
<span id="L1879"><span class="lineNum">    1879</span>              : </span>
<span id="L1880"><span class="lineNum">    1880</span>              :         return { __beg, __ite };</span>
<span id="L1881"><span class="lineNum">    1881</span>              :       }</span>
<span id="L1882"><span class="lineNum">    1882</span>              : </span>
<span id="L1883"><span class="lineNum">    1883</span>              :   template&lt;typename _Key, typename _Value, typename _Alloc,</span>
<span id="L1884"><span class="lineNum">    1884</span>              :            typename _ExtractKey, typename _Equal,</span>
<span id="L1885"><span class="lineNum">    1885</span>              :            typename _Hash, typename _RangeHash, typename _Unused,</span>
<span id="L1886"><span class="lineNum">    1886</span>              :            typename _RehashPolicy, typename _Traits&gt;</span>
<span id="L1887"><span class="lineNum">    1887</span>              :     template&lt;typename _Kt, typename, typename&gt;</span>
<span id="L1888"><span class="lineNum">    1888</span>              :       auto</span>
<span id="L1889"><span class="lineNum">    1889</span>              :       _Hashtable&lt;_Key, _Value, _Alloc, _ExtractKey, _Equal,</span>
<span id="L1890"><span class="lineNum">    1890</span>              :                  _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits&gt;::</span>
<span id="L1891"><span class="lineNum">    1891</span>              :       _M_equal_range_tr(const _Kt&amp; __k) const</span>
<span id="L1892"><span class="lineNum">    1892</span>              :       -&gt; pair&lt;const_iterator, const_iterator&gt;</span>
<span id="L1893"><span class="lineNum">    1893</span>              :       {</span>
<span id="L1894"><span class="lineNum">    1894</span>              :         __hash_code __code = this-&gt;_M_hash_code_tr(__k);</span>
<span id="L1895"><span class="lineNum">    1895</span>              :         std::size_t __bkt = _M_bucket_index(__code);</span>
<span id="L1896"><span class="lineNum">    1896</span>              :         auto __n = _M_find_node_tr(__bkt, __k, __code);</span>
<span id="L1897"><span class="lineNum">    1897</span>              :         const_iterator __ite(__n);</span>
<span id="L1898"><span class="lineNum">    1898</span>              :         if (!__n)</span>
<span id="L1899"><span class="lineNum">    1899</span>              :           return { __ite, __ite };</span>
<span id="L1900"><span class="lineNum">    1900</span>              : </span>
<span id="L1901"><span class="lineNum">    1901</span>              :         // All equivalent values are next to each other, if we find a</span>
<span id="L1902"><span class="lineNum">    1902</span>              :         // non-equivalent value after an equivalent one it means that we won't</span>
<span id="L1903"><span class="lineNum">    1903</span>              :         // find any new equivalent value.</span>
<span id="L1904"><span class="lineNum">    1904</span>              :         auto __beg = __ite++;</span>
<span id="L1905"><span class="lineNum">    1905</span>              :         while (__ite._M_cur &amp;&amp; this-&gt;_M_equals_tr(__k, __code, *__ite._M_cur))</span>
<span id="L1906"><span class="lineNum">    1906</span>              :           ++__ite;</span>
<span id="L1907"><span class="lineNum">    1907</span>              : </span>
<span id="L1908"><span class="lineNum">    1908</span>              :         return { __beg, __ite };</span>
<span id="L1909"><span class="lineNum">    1909</span>              :       }</span>
<span id="L1910"><span class="lineNum">    1910</span>              : #endif</span>
<span id="L1911"><span class="lineNum">    1911</span>              : </span>
<span id="L1912"><span class="lineNum">    1912</span>              :   // Find the node before the one whose key compares equal to k.</span>
<span id="L1913"><span class="lineNum">    1913</span>              :   // Return nullptr if no node is found.</span>
<span id="L1914"><span class="lineNum">    1914</span>              :   template&lt;typename _Key, typename _Value, typename _Alloc,</span>
<span id="L1915"><span class="lineNum">    1915</span>              :            typename _ExtractKey, typename _Equal,</span>
<span id="L1916"><span class="lineNum">    1916</span>              :            typename _Hash, typename _RangeHash, typename _Unused,</span>
<span id="L1917"><span class="lineNum">    1917</span>              :            typename _RehashPolicy, typename _Traits&gt;</span>
<span id="L1918"><span class="lineNum">    1918</span>              :     auto</span>
<span id="L1919"><span class="lineNum">    1919</span> <span class="tlaUNC">           0 :     _Hashtable&lt;_Key, _Value, _Alloc, _ExtractKey, _Equal,</span></span>
<span id="L1920"><span class="lineNum">    1920</span>              :                _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits&gt;::</span>
<span id="L1921"><span class="lineNum">    1921</span>              :     _M_find_before_node(const key_type&amp; __k)</span>
<span id="L1922"><span class="lineNum">    1922</span>              :     -&gt; __node_base_ptr</span>
<span id="L1923"><span class="lineNum">    1923</span>              :     {</span>
<span id="L1924"><span class="lineNum">    1924</span> <span class="tlaUNC">           0 :       __node_base_ptr __prev_p = &amp;_M_before_begin;</span></span>
<span id="L1925"><span class="lineNum">    1925</span> <span class="tlaUNC">           0 :       if (!__prev_p-&gt;_M_nxt)</span></span>
<span id="L1926"><span class="lineNum">    1926</span> <span class="tlaUNC">           0 :         return nullptr;</span></span>
<span id="L1927"><span class="lineNum">    1927</span>              : </span>
<span id="L1928"><span class="lineNum">    1928</span> <span class="tlaUNC">           0 :       for (__node_ptr __p = static_cast&lt;__node_ptr&gt;(__prev_p-&gt;_M_nxt);</span></span>
<span id="L1929"><span class="lineNum">    1929</span> <span class="tlaUNC">           0 :            __p != nullptr;</span></span>
<span id="L1930"><span class="lineNum">    1930</span> <span class="tlaUNC">           0 :            __p = __p-&gt;_M_next())</span></span>
<span id="L1931"><span class="lineNum">    1931</span>              :         {</span>
<span id="L1932"><span class="lineNum">    1932</span> <span class="tlaUNC">           0 :           if (this-&gt;_M_key_equals(__k, *__p))</span></span>
<span id="L1933"><span class="lineNum">    1933</span> <span class="tlaUNC">           0 :             return __prev_p;</span></span>
<span id="L1934"><span class="lineNum">    1934</span>              : </span>
<span id="L1935"><span class="lineNum">    1935</span> <span class="tlaUNC">           0 :           __prev_p = __p;</span></span>
<span id="L1936"><span class="lineNum">    1936</span>              :         }</span>
<span id="L1937"><span class="lineNum">    1937</span>              : </span>
<span id="L1938"><span class="lineNum">    1938</span> <span class="tlaUNC">           0 :       return nullptr;</span></span>
<span id="L1939"><span class="lineNum">    1939</span>              :     }</span>
<span id="L1940"><span class="lineNum">    1940</span>              : </span>
<span id="L1941"><span class="lineNum">    1941</span>              :   // Find the node before the one whose key compares equal to k in the bucket</span>
<span id="L1942"><span class="lineNum">    1942</span>              :   // bkt. Return nullptr if no node is found.</span>
<span id="L1943"><span class="lineNum">    1943</span>              :   template&lt;typename _Key, typename _Value, typename _Alloc,</span>
<span id="L1944"><span class="lineNum">    1944</span>              :            typename _ExtractKey, typename _Equal,</span>
<span id="L1945"><span class="lineNum">    1945</span>              :            typename _Hash, typename _RangeHash, typename _Unused,</span>
<span id="L1946"><span class="lineNum">    1946</span>              :            typename _RehashPolicy, typename _Traits&gt;</span>
<span id="L1947"><span class="lineNum">    1947</span>              :     auto</span>
<span id="L1948"><span class="lineNum">    1948</span> <span class="tlaGNC tlaBgGNC">           2 :     _Hashtable&lt;_Key, _Value, _Alloc, _ExtractKey, _Equal,</span></span>
<span id="L1949"><span class="lineNum">    1949</span>              :                _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits&gt;::</span>
<span id="L1950"><span class="lineNum">    1950</span>              :     _M_find_before_node(size_type __bkt, const key_type&amp; __k,</span>
<span id="L1951"><span class="lineNum">    1951</span>              :                         __hash_code __code) const</span>
<span id="L1952"><span class="lineNum">    1952</span>              :     -&gt; __node_base_ptr</span>
<span id="L1953"><span class="lineNum">    1953</span>              :     {</span>
<span id="L1954"><span class="lineNum">    1954</span> <span class="tlaGNC">           2 :       __node_base_ptr __prev_p = _M_buckets[__bkt];</span></span>
<span id="L1955"><span class="lineNum">    1955</span> <span class="tlaGNC">           2 :       if (!__prev_p)</span></span>
<span id="L1956"><span class="lineNum">    1956</span> <span class="tlaGNC">           2 :         return nullptr;</span></span>
<span id="L1957"><span class="lineNum">    1957</span>              : </span>
<span id="L1958"><span class="lineNum">    1958</span> <span class="tlaUNC tlaBgUNC">           0 :       for (__node_ptr __p = static_cast&lt;__node_ptr&gt;(__prev_p-&gt;_M_nxt);;</span></span>
<span id="L1959"><span class="lineNum">    1959</span> <span class="tlaUNC">           0 :            __p = __p-&gt;_M_next())</span></span>
<span id="L1960"><span class="lineNum">    1960</span>              :         {</span>
<span id="L1961"><span class="lineNum">    1961</span> <span class="tlaUNC">           0 :           if (this-&gt;_M_equals(__k, __code, *__p))</span></span>
<span id="L1962"><span class="lineNum">    1962</span> <span class="tlaUNC">           0 :             return __prev_p;</span></span>
<span id="L1963"><span class="lineNum">    1963</span>              : </span>
<span id="L1964"><span class="lineNum">    1964</span> <span class="tlaUNC">           0 :           if (!__p-&gt;_M_nxt || _M_bucket_index(*__p-&gt;_M_next()) != __bkt)</span></span>
<span id="L1965"><span class="lineNum">    1965</span> <span class="tlaUNC">           0 :             break;</span></span>
<span id="L1966"><span class="lineNum">    1966</span> <span class="tlaUNC">           0 :           __prev_p = __p;</span></span>
<span id="L1967"><span class="lineNum">    1967</span>              :         }</span>
<span id="L1968"><span class="lineNum">    1968</span>              : </span>
<span id="L1969"><span class="lineNum">    1969</span> <span class="tlaUNC">           0 :       return nullptr;</span></span>
<span id="L1970"><span class="lineNum">    1970</span>              :     }</span>
<span id="L1971"><span class="lineNum">    1971</span>              : </span>
<span id="L1972"><span class="lineNum">    1972</span>              :   template&lt;typename _Key, typename _Value, typename _Alloc,</span>
<span id="L1973"><span class="lineNum">    1973</span>              :            typename _ExtractKey, typename _Equal,</span>
<span id="L1974"><span class="lineNum">    1974</span>              :            typename _Hash, typename _RangeHash, typename _Unused,</span>
<span id="L1975"><span class="lineNum">    1975</span>              :            typename _RehashPolicy, typename _Traits&gt;</span>
<span id="L1976"><span class="lineNum">    1976</span>              :     template&lt;typename _Kt&gt;</span>
<span id="L1977"><span class="lineNum">    1977</span>              :       auto</span>
<span id="L1978"><span class="lineNum">    1978</span>              :       _Hashtable&lt;_Key, _Value, _Alloc, _ExtractKey, _Equal,</span>
<span id="L1979"><span class="lineNum">    1979</span>              :                  _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits&gt;::</span>
<span id="L1980"><span class="lineNum">    1980</span>              :       _M_find_before_node_tr(size_type __bkt, const _Kt&amp; __k,</span>
<span id="L1981"><span class="lineNum">    1981</span>              :                              __hash_code __code) const</span>
<span id="L1982"><span class="lineNum">    1982</span>              :       -&gt; __node_base_ptr</span>
<span id="L1983"><span class="lineNum">    1983</span>              :       {</span>
<span id="L1984"><span class="lineNum">    1984</span>              :         __node_base_ptr __prev_p = _M_buckets[__bkt];</span>
<span id="L1985"><span class="lineNum">    1985</span>              :         if (!__prev_p)</span>
<span id="L1986"><span class="lineNum">    1986</span>              :           return nullptr;</span>
<span id="L1987"><span class="lineNum">    1987</span>              : </span>
<span id="L1988"><span class="lineNum">    1988</span>              :         for (__node_ptr __p = static_cast&lt;__node_ptr&gt;(__prev_p-&gt;_M_nxt);;</span>
<span id="L1989"><span class="lineNum">    1989</span>              :              __p = __p-&gt;_M_next())</span>
<span id="L1990"><span class="lineNum">    1990</span>              :           {</span>
<span id="L1991"><span class="lineNum">    1991</span>              :             if (this-&gt;_M_equals_tr(__k, __code, *__p))</span>
<span id="L1992"><span class="lineNum">    1992</span>              :               return __prev_p;</span>
<span id="L1993"><span class="lineNum">    1993</span>              : </span>
<span id="L1994"><span class="lineNum">    1994</span>              :             if (!__p-&gt;_M_nxt || _M_bucket_index(*__p-&gt;_M_next()) != __bkt)</span>
<span id="L1995"><span class="lineNum">    1995</span>              :               break;</span>
<span id="L1996"><span class="lineNum">    1996</span>              :             __prev_p = __p;</span>
<span id="L1997"><span class="lineNum">    1997</span>              :           }</span>
<span id="L1998"><span class="lineNum">    1998</span>              : </span>
<span id="L1999"><span class="lineNum">    1999</span>              :         return nullptr;</span>
<span id="L2000"><span class="lineNum">    2000</span>              :       }</span>
<span id="L2001"><span class="lineNum">    2001</span>              : </span>
<span id="L2002"><span class="lineNum">    2002</span>              :   template&lt;typename _Key, typename _Value, typename _Alloc,</span>
<span id="L2003"><span class="lineNum">    2003</span>              :            typename _ExtractKey, typename _Equal,</span>
<span id="L2004"><span class="lineNum">    2004</span>              :            typename _Hash, typename _RangeHash, typename _Unused,</span>
<span id="L2005"><span class="lineNum">    2005</span>              :            typename _RehashPolicy, typename _Traits&gt;</span>
<span id="L2006"><span class="lineNum">    2006</span>              :     void</span>
<span id="L2007"><span class="lineNum">    2007</span> <span class="tlaGNC tlaBgGNC">           2 :     _Hashtable&lt;_Key, _Value, _Alloc, _ExtractKey, _Equal,</span></span>
<span id="L2008"><span class="lineNum">    2008</span>              :                _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits&gt;::</span>
<span id="L2009"><span class="lineNum">    2009</span>              :     _M_insert_bucket_begin(size_type __bkt, __node_ptr __node)</span>
<span id="L2010"><span class="lineNum">    2010</span>              :     {</span>
<span id="L2011"><span class="lineNum">    2011</span> <span class="tlaGNC">           2 :       if (_M_buckets[__bkt])</span></span>
<span id="L2012"><span class="lineNum">    2012</span>              :         {</span>
<span id="L2013"><span class="lineNum">    2013</span>              :           // Bucket is not empty, we just need to insert the new node</span>
<span id="L2014"><span class="lineNum">    2014</span>              :           // after the bucket before begin.</span>
<span id="L2015"><span class="lineNum">    2015</span> <span class="tlaUNC tlaBgUNC">           0 :           __node-&gt;_M_nxt = _M_buckets[__bkt]-&gt;_M_nxt;</span></span>
<span id="L2016"><span class="lineNum">    2016</span> <span class="tlaUNC">           0 :           _M_buckets[__bkt]-&gt;_M_nxt = __node;</span></span>
<span id="L2017"><span class="lineNum">    2017</span>              :         }</span>
<span id="L2018"><span class="lineNum">    2018</span>              :       else</span>
<span id="L2019"><span class="lineNum">    2019</span>              :         {</span>
<span id="L2020"><span class="lineNum">    2020</span>              :           // The bucket is empty, the new node is inserted at the</span>
<span id="L2021"><span class="lineNum">    2021</span>              :           // beginning of the singly-linked list and the bucket will</span>
<span id="L2022"><span class="lineNum">    2022</span>              :           // contain _M_before_begin pointer.</span>
<span id="L2023"><span class="lineNum">    2023</span> <span class="tlaGNC tlaBgGNC">           2 :           __node-&gt;_M_nxt = _M_before_begin._M_nxt;</span></span>
<span id="L2024"><span class="lineNum">    2024</span> <span class="tlaGNC">           2 :           _M_before_begin._M_nxt = __node;</span></span>
<span id="L2025"><span class="lineNum">    2025</span>              : </span>
<span id="L2026"><span class="lineNum">    2026</span> <span class="tlaGNC">           2 :           if (__node-&gt;_M_nxt)</span></span>
<span id="L2027"><span class="lineNum">    2027</span>              :             // We must update former begin bucket that is pointing to</span>
<span id="L2028"><span class="lineNum">    2028</span>              :             // _M_before_begin.</span>
<span id="L2029"><span class="lineNum">    2029</span> <span class="tlaUNC tlaBgUNC">           0 :             _M_buckets[_M_bucket_index(*__node-&gt;_M_next())] = __node;</span></span>
<span id="L2030"><span class="lineNum">    2030</span>              : </span>
<span id="L2031"><span class="lineNum">    2031</span> <span class="tlaGNC tlaBgGNC">           2 :           _M_buckets[__bkt] = &amp;_M_before_begin;</span></span>
<span id="L2032"><span class="lineNum">    2032</span>              :         }</span>
<span id="L2033"><span class="lineNum">    2033</span> <span class="tlaGNC">           2 :     }</span></span>
<span id="L2034"><span class="lineNum">    2034</span>              : </span>
<span id="L2035"><span class="lineNum">    2035</span>              :   template&lt;typename _Key, typename _Value, typename _Alloc,</span>
<span id="L2036"><span class="lineNum">    2036</span>              :            typename _ExtractKey, typename _Equal,</span>
<span id="L2037"><span class="lineNum">    2037</span>              :            typename _Hash, typename _RangeHash, typename _Unused,</span>
<span id="L2038"><span class="lineNum">    2038</span>              :            typename _RehashPolicy, typename _Traits&gt;</span>
<span id="L2039"><span class="lineNum">    2039</span>              :     void</span>
<span id="L2040"><span class="lineNum">    2040</span> <span class="tlaUNC tlaBgUNC">           0 :     _Hashtable&lt;_Key, _Value, _Alloc, _ExtractKey, _Equal,</span></span>
<span id="L2041"><span class="lineNum">    2041</span>              :                _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits&gt;::</span>
<span id="L2042"><span class="lineNum">    2042</span>              :     _M_remove_bucket_begin(size_type __bkt, __node_ptr __next,</span>
<span id="L2043"><span class="lineNum">    2043</span>              :                            size_type __next_bkt)</span>
<span id="L2044"><span class="lineNum">    2044</span>              :     {</span>
<span id="L2045"><span class="lineNum">    2045</span> <span class="tlaUNC">           0 :       if (!__next || __next_bkt != __bkt)</span></span>
<span id="L2046"><span class="lineNum">    2046</span>              :         {</span>
<span id="L2047"><span class="lineNum">    2047</span>              :           // Bucket is now empty</span>
<span id="L2048"><span class="lineNum">    2048</span>              :           // First update next bucket if any</span>
<span id="L2049"><span class="lineNum">    2049</span> <span class="tlaUNC">           0 :           if (__next)</span></span>
<span id="L2050"><span class="lineNum">    2050</span> <span class="tlaUNC">           0 :             _M_buckets[__next_bkt] = _M_buckets[__bkt];</span></span>
<span id="L2051"><span class="lineNum">    2051</span>              : </span>
<span id="L2052"><span class="lineNum">    2052</span>              :           // Second update before begin node if necessary</span>
<span id="L2053"><span class="lineNum">    2053</span> <span class="tlaUNC">           0 :           if (&amp;_M_before_begin == _M_buckets[__bkt])</span></span>
<span id="L2054"><span class="lineNum">    2054</span> <span class="tlaUNC">           0 :             _M_before_begin._M_nxt = __next;</span></span>
<span id="L2055"><span class="lineNum">    2055</span> <span class="tlaUNC">           0 :           _M_buckets[__bkt] = nullptr;</span></span>
<span id="L2056"><span class="lineNum">    2056</span>              :         }</span>
<span id="L2057"><span class="lineNum">    2057</span> <span class="tlaUNC">           0 :     }</span></span>
<span id="L2058"><span class="lineNum">    2058</span>              : </span>
<span id="L2059"><span class="lineNum">    2059</span>              :   template&lt;typename _Key, typename _Value, typename _Alloc,</span>
<span id="L2060"><span class="lineNum">    2060</span>              :            typename _ExtractKey, typename _Equal,</span>
<span id="L2061"><span class="lineNum">    2061</span>              :            typename _Hash, typename _RangeHash, typename _Unused,</span>
<span id="L2062"><span class="lineNum">    2062</span>              :            typename _RehashPolicy, typename _Traits&gt;</span>
<span id="L2063"><span class="lineNum">    2063</span>              :     auto</span>
<span id="L2064"><span class="lineNum">    2064</span>              :     _Hashtable&lt;_Key, _Value, _Alloc, _ExtractKey, _Equal,</span>
<span id="L2065"><span class="lineNum">    2065</span>              :                _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits&gt;::</span>
<span id="L2066"><span class="lineNum">    2066</span>              :     _M_get_previous_node(size_type __bkt, __node_ptr __n)</span>
<span id="L2067"><span class="lineNum">    2067</span>              :     -&gt; __node_base_ptr</span>
<span id="L2068"><span class="lineNum">    2068</span>              :     {</span>
<span id="L2069"><span class="lineNum">    2069</span>              :       __node_base_ptr __prev_n = _M_buckets[__bkt];</span>
<span id="L2070"><span class="lineNum">    2070</span>              :       while (__prev_n-&gt;_M_nxt != __n)</span>
<span id="L2071"><span class="lineNum">    2071</span>              :         __prev_n = __prev_n-&gt;_M_nxt;</span>
<span id="L2072"><span class="lineNum">    2072</span>              :       return __prev_n;</span>
<span id="L2073"><span class="lineNum">    2073</span>              :     }</span>
<span id="L2074"><span class="lineNum">    2074</span>              : </span>
<span id="L2075"><span class="lineNum">    2075</span>              :   template&lt;typename _Key, typename _Value, typename _Alloc,</span>
<span id="L2076"><span class="lineNum">    2076</span>              :            typename _ExtractKey, typename _Equal,</span>
<span id="L2077"><span class="lineNum">    2077</span>              :            typename _Hash, typename _RangeHash, typename _Unused,</span>
<span id="L2078"><span class="lineNum">    2078</span>              :            typename _RehashPolicy, typename _Traits&gt;</span>
<span id="L2079"><span class="lineNum">    2079</span>              :     template&lt;typename... _Args&gt;</span>
<span id="L2080"><span class="lineNum">    2080</span>              :       auto</span>
<span id="L2081"><span class="lineNum">    2081</span>              :       _Hashtable&lt;_Key, _Value, _Alloc, _ExtractKey, _Equal,</span>
<span id="L2082"><span class="lineNum">    2082</span>              :                  _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits&gt;::</span>
<span id="L2083"><span class="lineNum">    2083</span>              :       _M_emplace(true_type /* __uks */, _Args&amp;&amp;... __args)</span>
<span id="L2084"><span class="lineNum">    2084</span>              :       -&gt; pair&lt;iterator, bool&gt;</span>
<span id="L2085"><span class="lineNum">    2085</span>              :       {</span>
<span id="L2086"><span class="lineNum">    2086</span>              :         // First build the node to get access to the hash code</span>
<span id="L2087"><span class="lineNum">    2087</span>              :         _Scoped_node __node { this, std::forward&lt;_Args&gt;(__args)...  };</span>
<span id="L2088"><span class="lineNum">    2088</span>              :         const key_type&amp; __k = _ExtractKey{}(__node._M_node-&gt;_M_v());</span>
<span id="L2089"><span class="lineNum">    2089</span>              :         if (size() &lt;= __small_size_threshold())</span>
<span id="L2090"><span class="lineNum">    2090</span>              :           {</span>
<span id="L2091"><span class="lineNum">    2091</span>              :             for (auto __it = begin(); __it != end(); ++__it)</span>
<span id="L2092"><span class="lineNum">    2092</span>              :               if (this-&gt;_M_key_equals(__k, *__it._M_cur))</span>
<span id="L2093"><span class="lineNum">    2093</span>              :                 // There is already an equivalent node, no insertion</span>
<span id="L2094"><span class="lineNum">    2094</span>              :                 return { __it, false };</span>
<span id="L2095"><span class="lineNum">    2095</span>              :           }</span>
<span id="L2096"><span class="lineNum">    2096</span>              : </span>
<span id="L2097"><span class="lineNum">    2097</span>              :         __hash_code __code = this-&gt;_M_hash_code(__k);</span>
<span id="L2098"><span class="lineNum">    2098</span>              :         size_type __bkt = _M_bucket_index(__code);</span>
<span id="L2099"><span class="lineNum">    2099</span>              :         if (size() &gt; __small_size_threshold())</span>
<span id="L2100"><span class="lineNum">    2100</span>              :           if (__node_ptr __p = _M_find_node(__bkt, __k, __code))</span>
<span id="L2101"><span class="lineNum">    2101</span>              :             // There is already an equivalent node, no insertion</span>
<span id="L2102"><span class="lineNum">    2102</span>              :             return { iterator(__p), false };</span>
<span id="L2103"><span class="lineNum">    2103</span>              : </span>
<span id="L2104"><span class="lineNum">    2104</span>              :         // Insert the node</span>
<span id="L2105"><span class="lineNum">    2105</span>              :         auto __pos = _M_insert_unique_node(__bkt, __code, __node._M_node);</span>
<span id="L2106"><span class="lineNum">    2106</span>              :         __node._M_node = nullptr;</span>
<span id="L2107"><span class="lineNum">    2107</span>              :         return { __pos, true };</span>
<span id="L2108"><span class="lineNum">    2108</span>              :       }</span>
<span id="L2109"><span class="lineNum">    2109</span>              : </span>
<span id="L2110"><span class="lineNum">    2110</span>              :   template&lt;typename _Key, typename _Value, typename _Alloc,</span>
<span id="L2111"><span class="lineNum">    2111</span>              :            typename _ExtractKey, typename _Equal,</span>
<span id="L2112"><span class="lineNum">    2112</span>              :            typename _Hash, typename _RangeHash, typename _Unused,</span>
<span id="L2113"><span class="lineNum">    2113</span>              :            typename _RehashPolicy, typename _Traits&gt;</span>
<span id="L2114"><span class="lineNum">    2114</span>              :     template&lt;typename... _Args&gt;</span>
<span id="L2115"><span class="lineNum">    2115</span>              :       auto</span>
<span id="L2116"><span class="lineNum">    2116</span>              :       _Hashtable&lt;_Key, _Value, _Alloc, _ExtractKey, _Equal,</span>
<span id="L2117"><span class="lineNum">    2117</span>              :                  _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits&gt;::</span>
<span id="L2118"><span class="lineNum">    2118</span>              :       _M_emplace(const_iterator __hint, false_type /* __uks */,</span>
<span id="L2119"><span class="lineNum">    2119</span>              :                  _Args&amp;&amp;... __args)</span>
<span id="L2120"><span class="lineNum">    2120</span>              :       -&gt; iterator</span>
<span id="L2121"><span class="lineNum">    2121</span>              :       {</span>
<span id="L2122"><span class="lineNum">    2122</span>              :         // First build the node to get its hash code.</span>
<span id="L2123"><span class="lineNum">    2123</span>              :         _Scoped_node __node { this, std::forward&lt;_Args&gt;(__args)...  };</span>
<span id="L2124"><span class="lineNum">    2124</span>              :         const key_type&amp; __k = _ExtractKey{}(__node._M_node-&gt;_M_v());</span>
<span id="L2125"><span class="lineNum">    2125</span>              : </span>
<span id="L2126"><span class="lineNum">    2126</span>              :         auto __res = this-&gt;_M_compute_hash_code(__hint, __k);</span>
<span id="L2127"><span class="lineNum">    2127</span>              :         auto __pos</span>
<span id="L2128"><span class="lineNum">    2128</span>              :           = _M_insert_multi_node(__res.first._M_cur, __res.second,</span>
<span id="L2129"><span class="lineNum">    2129</span>              :                                  __node._M_node);</span>
<span id="L2130"><span class="lineNum">    2130</span>              :         __node._M_node = nullptr;</span>
<span id="L2131"><span class="lineNum">    2131</span>              :         return __pos;</span>
<span id="L2132"><span class="lineNum">    2132</span>              :       }</span>
<span id="L2133"><span class="lineNum">    2133</span>              : </span>
<span id="L2134"><span class="lineNum">    2134</span>              :   template&lt;typename _Key, typename _Value, typename _Alloc,</span>
<span id="L2135"><span class="lineNum">    2135</span>              :            typename _ExtractKey, typename _Equal,</span>
<span id="L2136"><span class="lineNum">    2136</span>              :            typename _Hash, typename _RangeHash, typename _Unused,</span>
<span id="L2137"><span class="lineNum">    2137</span>              :            typename _RehashPolicy, typename _Traits&gt;</span>
<span id="L2138"><span class="lineNum">    2138</span>              :     auto</span>
<span id="L2139"><span class="lineNum">    2139</span>              :     _Hashtable&lt;_Key, _Value, _Alloc, _ExtractKey, _Equal,</span>
<span id="L2140"><span class="lineNum">    2140</span>              :                _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits&gt;::</span>
<span id="L2141"><span class="lineNum">    2141</span>              :     _M_compute_hash_code(const_iterator __hint, const key_type&amp; __k) const</span>
<span id="L2142"><span class="lineNum">    2142</span>              :     -&gt; pair&lt;const_iterator, __hash_code&gt;</span>
<span id="L2143"><span class="lineNum">    2143</span>              :     {</span>
<span id="L2144"><span class="lineNum">    2144</span>              :       if (size() &lt;= __small_size_threshold())</span>
<span id="L2145"><span class="lineNum">    2145</span>              :         {</span>
<span id="L2146"><span class="lineNum">    2146</span>              :           if (__hint != cend())</span>
<span id="L2147"><span class="lineNum">    2147</span>              :             {</span>
<span id="L2148"><span class="lineNum">    2148</span>              :               for (auto __it = __hint; __it != cend(); ++__it)</span>
<span id="L2149"><span class="lineNum">    2149</span>              :                 if (this-&gt;_M_key_equals(__k, *__it._M_cur))</span>
<span id="L2150"><span class="lineNum">    2150</span>              :                   return { __it, this-&gt;_M_hash_code(*__it._M_cur) };</span>
<span id="L2151"><span class="lineNum">    2151</span>              :             }</span>
<span id="L2152"><span class="lineNum">    2152</span>              : </span>
<span id="L2153"><span class="lineNum">    2153</span>              :           for (auto __it = cbegin(); __it != __hint; ++__it)</span>
<span id="L2154"><span class="lineNum">    2154</span>              :             if (this-&gt;_M_key_equals(__k, *__it._M_cur))</span>
<span id="L2155"><span class="lineNum">    2155</span>              :               return { __it, this-&gt;_M_hash_code(*__it._M_cur) };</span>
<span id="L2156"><span class="lineNum">    2156</span>              :         }</span>
<span id="L2157"><span class="lineNum">    2157</span>              : </span>
<span id="L2158"><span class="lineNum">    2158</span>              :       return { __hint, this-&gt;_M_hash_code(__k) };</span>
<span id="L2159"><span class="lineNum">    2159</span>              :     }</span>
<span id="L2160"><span class="lineNum">    2160</span>              : </span>
<span id="L2161"><span class="lineNum">    2161</span>              :   template&lt;typename _Key, typename _Value, typename _Alloc,</span>
<span id="L2162"><span class="lineNum">    2162</span>              :            typename _ExtractKey, typename _Equal,</span>
<span id="L2163"><span class="lineNum">    2163</span>              :            typename _Hash, typename _RangeHash, typename _Unused,</span>
<span id="L2164"><span class="lineNum">    2164</span>              :            typename _RehashPolicy, typename _Traits&gt;</span>
<span id="L2165"><span class="lineNum">    2165</span>              :     auto</span>
<span id="L2166"><span class="lineNum">    2166</span> <span class="tlaGNC tlaBgGNC">           2 :     _Hashtable&lt;_Key, _Value, _Alloc, _ExtractKey, _Equal,</span></span>
<span id="L2167"><span class="lineNum">    2167</span>              :                _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits&gt;::</span>
<span id="L2168"><span class="lineNum">    2168</span>              :     _M_insert_unique_node(size_type __bkt, __hash_code __code,</span>
<span id="L2169"><span class="lineNum">    2169</span>              :                           __node_ptr __node, size_type __n_elt)</span>
<span id="L2170"><span class="lineNum">    2170</span>              :     -&gt; iterator</span>
<span id="L2171"><span class="lineNum">    2171</span>              :     {</span>
<span id="L2172"><span class="lineNum">    2172</span> <span class="tlaGNC">           2 :       const __rehash_state&amp; __saved_state = _M_rehash_policy._M_state();</span></span>
<span id="L2173"><span class="lineNum">    2173</span>              :       std::pair&lt;bool, std::size_t&gt; __do_rehash</span>
<span id="L2174"><span class="lineNum">    2174</span> <span class="tlaGNC">           2 :         = _M_rehash_policy._M_need_rehash(_M_bucket_count, _M_element_count,</span></span>
<span id="L2175"><span class="lineNum">    2175</span>              :                                           __n_elt);</span>
<span id="L2176"><span class="lineNum">    2176</span>              : </span>
<span id="L2177"><span class="lineNum">    2177</span> <span class="tlaGNC">           2 :       if (__do_rehash.first)</span></span>
<span id="L2178"><span class="lineNum">    2178</span>              :         {</span>
<span id="L2179"><span class="lineNum">    2179</span> <span class="tlaGNC">           2 :           _M_rehash(__do_rehash.second, __saved_state);</span></span>
<span id="L2180"><span class="lineNum">    2180</span> <span class="tlaGNC">           2 :           __bkt = _M_bucket_index(__code);</span></span>
<span id="L2181"><span class="lineNum">    2181</span>              :         }</span>
<span id="L2182"><span class="lineNum">    2182</span>              : </span>
<span id="L2183"><span class="lineNum">    2183</span> <span class="tlaGNC">           2 :       this-&gt;_M_store_code(*__node, __code);</span></span>
<span id="L2184"><span class="lineNum">    2184</span>              : </span>
<span id="L2185"><span class="lineNum">    2185</span>              :       // Always insert at the beginning of the bucket.</span>
<span id="L2186"><span class="lineNum">    2186</span> <span class="tlaGNC">           2 :       _M_insert_bucket_begin(__bkt, __node);</span></span>
<span id="L2187"><span class="lineNum">    2187</span> <span class="tlaGNC">           2 :       ++_M_element_count;</span></span>
<span id="L2188"><span class="lineNum">    2188</span> <span class="tlaGNC">           2 :       return iterator(__node);</span></span>
<span id="L2189"><span class="lineNum">    2189</span>              :     }</span>
<span id="L2190"><span class="lineNum">    2190</span>              : </span>
<span id="L2191"><span class="lineNum">    2191</span>              :   template&lt;typename _Key, typename _Value, typename _Alloc,</span>
<span id="L2192"><span class="lineNum">    2192</span>              :            typename _ExtractKey, typename _Equal,</span>
<span id="L2193"><span class="lineNum">    2193</span>              :            typename _Hash, typename _RangeHash, typename _Unused,</span>
<span id="L2194"><span class="lineNum">    2194</span>              :            typename _RehashPolicy, typename _Traits&gt;</span>
<span id="L2195"><span class="lineNum">    2195</span>              :     auto</span>
<span id="L2196"><span class="lineNum">    2196</span>              :     _Hashtable&lt;_Key, _Value, _Alloc, _ExtractKey, _Equal,</span>
<span id="L2197"><span class="lineNum">    2197</span>              :                _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits&gt;::</span>
<span id="L2198"><span class="lineNum">    2198</span>              :     _M_insert_multi_node(__node_ptr __hint,</span>
<span id="L2199"><span class="lineNum">    2199</span>              :                          __hash_code __code, __node_ptr __node)</span>
<span id="L2200"><span class="lineNum">    2200</span>              :     -&gt; iterator</span>
<span id="L2201"><span class="lineNum">    2201</span>              :     {</span>
<span id="L2202"><span class="lineNum">    2202</span>              :       const __rehash_state&amp; __saved_state = _M_rehash_policy._M_state();</span>
<span id="L2203"><span class="lineNum">    2203</span>              :       std::pair&lt;bool, std::size_t&gt; __do_rehash</span>
<span id="L2204"><span class="lineNum">    2204</span>              :         = _M_rehash_policy._M_need_rehash(_M_bucket_count, _M_element_count, 1);</span>
<span id="L2205"><span class="lineNum">    2205</span>              : </span>
<span id="L2206"><span class="lineNum">    2206</span>              :       if (__do_rehash.first)</span>
<span id="L2207"><span class="lineNum">    2207</span>              :         _M_rehash(__do_rehash.second, __saved_state);</span>
<span id="L2208"><span class="lineNum">    2208</span>              : </span>
<span id="L2209"><span class="lineNum">    2209</span>              :       this-&gt;_M_store_code(*__node, __code);</span>
<span id="L2210"><span class="lineNum">    2210</span>              :       const key_type&amp; __k = _ExtractKey{}(__node-&gt;_M_v());</span>
<span id="L2211"><span class="lineNum">    2211</span>              :       size_type __bkt = _M_bucket_index(__code);</span>
<span id="L2212"><span class="lineNum">    2212</span>              : </span>
<span id="L2213"><span class="lineNum">    2213</span>              :       // Find the node before an equivalent one or use hint if it exists and</span>
<span id="L2214"><span class="lineNum">    2214</span>              :       // if it is equivalent.</span>
<span id="L2215"><span class="lineNum">    2215</span>              :       __node_base_ptr __prev</span>
<span id="L2216"><span class="lineNum">    2216</span>              :         = __builtin_expect(__hint != nullptr, false)</span>
<span id="L2217"><span class="lineNum">    2217</span>              :           &amp;&amp; this-&gt;_M_equals(__k, __code, *__hint)</span>
<span id="L2218"><span class="lineNum">    2218</span>              :             ? __hint</span>
<span id="L2219"><span class="lineNum">    2219</span>              :             : _M_find_before_node(__bkt, __k, __code);</span>
<span id="L2220"><span class="lineNum">    2220</span>              : </span>
<span id="L2221"><span class="lineNum">    2221</span>              :       if (__prev)</span>
<span id="L2222"><span class="lineNum">    2222</span>              :         {</span>
<span id="L2223"><span class="lineNum">    2223</span>              :           // Insert after the node before the equivalent one.</span>
<span id="L2224"><span class="lineNum">    2224</span>              :           __node-&gt;_M_nxt = __prev-&gt;_M_nxt;</span>
<span id="L2225"><span class="lineNum">    2225</span>              :           __prev-&gt;_M_nxt = __node;</span>
<span id="L2226"><span class="lineNum">    2226</span>              :           if (__builtin_expect(__prev == __hint, false))</span>
<span id="L2227"><span class="lineNum">    2227</span>              :             // hint might be the last bucket node, in this case we need to</span>
<span id="L2228"><span class="lineNum">    2228</span>              :             // update next bucket.</span>
<span id="L2229"><span class="lineNum">    2229</span>              :             if (__node-&gt;_M_nxt</span>
<span id="L2230"><span class="lineNum">    2230</span>              :                 &amp;&amp; !this-&gt;_M_equals(__k, __code, *__node-&gt;_M_next()))</span>
<span id="L2231"><span class="lineNum">    2231</span>              :               {</span>
<span id="L2232"><span class="lineNum">    2232</span>              :                 size_type __next_bkt = _M_bucket_index(*__node-&gt;_M_next());</span>
<span id="L2233"><span class="lineNum">    2233</span>              :                 if (__next_bkt != __bkt)</span>
<span id="L2234"><span class="lineNum">    2234</span>              :                   _M_buckets[__next_bkt] = __node;</span>
<span id="L2235"><span class="lineNum">    2235</span>              :               }</span>
<span id="L2236"><span class="lineNum">    2236</span>              :         }</span>
<span id="L2237"><span class="lineNum">    2237</span>              :       else</span>
<span id="L2238"><span class="lineNum">    2238</span>              :         // The inserted node has no equivalent in the hashtable. We must</span>
<span id="L2239"><span class="lineNum">    2239</span>              :         // insert the new node at the beginning of the bucket to preserve</span>
<span id="L2240"><span class="lineNum">    2240</span>              :         // equivalent elements' relative positions.</span>
<span id="L2241"><span class="lineNum">    2241</span>              :         _M_insert_bucket_begin(__bkt, __node);</span>
<span id="L2242"><span class="lineNum">    2242</span>              :       ++_M_element_count;</span>
<span id="L2243"><span class="lineNum">    2243</span>              :       return iterator(__node);</span>
<span id="L2244"><span class="lineNum">    2244</span>              :     }</span>
<span id="L2245"><span class="lineNum">    2245</span>              : </span>
<span id="L2246"><span class="lineNum">    2246</span>              :   // Insert v if no element with its key is already present.</span>
<span id="L2247"><span class="lineNum">    2247</span>              :   template&lt;typename _Key, typename _Value, typename _Alloc,</span>
<span id="L2248"><span class="lineNum">    2248</span>              :            typename _ExtractKey, typename _Equal,</span>
<span id="L2249"><span class="lineNum">    2249</span>              :            typename _Hash, typename _RangeHash, typename _Unused,</span>
<span id="L2250"><span class="lineNum">    2250</span>              :            typename _RehashPolicy, typename _Traits&gt;</span>
<span id="L2251"><span class="lineNum">    2251</span>              :     template&lt;typename _Kt, typename _Arg, typename _NodeGenerator&gt;</span>
<span id="L2252"><span class="lineNum">    2252</span>              :       auto</span>
<span id="L2253"><span class="lineNum">    2253</span>              :       _Hashtable&lt;_Key, _Value, _Alloc, _ExtractKey, _Equal,</span>
<span id="L2254"><span class="lineNum">    2254</span>              :                  _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits&gt;::</span>
<span id="L2255"><span class="lineNum">    2255</span>              :       _M_insert_unique(_Kt&amp;&amp; __k, _Arg&amp;&amp; __v,</span>
<span id="L2256"><span class="lineNum">    2256</span>              :                        const _NodeGenerator&amp; __node_gen)</span>
<span id="L2257"><span class="lineNum">    2257</span>              :       -&gt; pair&lt;iterator, bool&gt;</span>
<span id="L2258"><span class="lineNum">    2258</span>              :       {</span>
<span id="L2259"><span class="lineNum">    2259</span>              :         if (size() &lt;= __small_size_threshold())</span>
<span id="L2260"><span class="lineNum">    2260</span>              :           for (auto __it = begin(); __it != end(); ++__it)</span>
<span id="L2261"><span class="lineNum">    2261</span>              :             if (this-&gt;_M_key_equals_tr(__k, *__it._M_cur))</span>
<span id="L2262"><span class="lineNum">    2262</span>              :               return { __it, false };</span>
<span id="L2263"><span class="lineNum">    2263</span>              : </span>
<span id="L2264"><span class="lineNum">    2264</span>              :         __hash_code __code = this-&gt;_M_hash_code_tr(__k);</span>
<span id="L2265"><span class="lineNum">    2265</span>              :         size_type __bkt = _M_bucket_index(__code);</span>
<span id="L2266"><span class="lineNum">    2266</span>              : </span>
<span id="L2267"><span class="lineNum">    2267</span>              :         if (size() &gt; __small_size_threshold())</span>
<span id="L2268"><span class="lineNum">    2268</span>              :           if (__node_ptr __node = _M_find_node_tr(__bkt, __k, __code))</span>
<span id="L2269"><span class="lineNum">    2269</span>              :             return { iterator(__node), false };</span>
<span id="L2270"><span class="lineNum">    2270</span>              : </span>
<span id="L2271"><span class="lineNum">    2271</span>              :         _Scoped_node __node {</span>
<span id="L2272"><span class="lineNum">    2272</span>              :           __node_builder_t::_S_build(std::forward&lt;_Kt&gt;(__k),</span>
<span id="L2273"><span class="lineNum">    2273</span>              :                                      std::forward&lt;_Arg&gt;(__v),</span>
<span id="L2274"><span class="lineNum">    2274</span>              :                                      __node_gen),</span>
<span id="L2275"><span class="lineNum">    2275</span>              :           this</span>
<span id="L2276"><span class="lineNum">    2276</span>              :         };</span>
<span id="L2277"><span class="lineNum">    2277</span>              :         auto __pos</span>
<span id="L2278"><span class="lineNum">    2278</span>              :           = _M_insert_unique_node(__bkt, __code, __node._M_node);</span>
<span id="L2279"><span class="lineNum">    2279</span>              :         __node._M_node = nullptr;</span>
<span id="L2280"><span class="lineNum">    2280</span>              :         return { __pos, true };</span>
<span id="L2281"><span class="lineNum">    2281</span>              :       }</span>
<span id="L2282"><span class="lineNum">    2282</span>              : </span>
<span id="L2283"><span class="lineNum">    2283</span>              :   // Insert v unconditionally.</span>
<span id="L2284"><span class="lineNum">    2284</span>              :   template&lt;typename _Key, typename _Value, typename _Alloc,</span>
<span id="L2285"><span class="lineNum">    2285</span>              :            typename _ExtractKey, typename _Equal,</span>
<span id="L2286"><span class="lineNum">    2286</span>              :            typename _Hash, typename _RangeHash, typename _Unused,</span>
<span id="L2287"><span class="lineNum">    2287</span>              :            typename _RehashPolicy, typename _Traits&gt;</span>
<span id="L2288"><span class="lineNum">    2288</span>              :     template&lt;typename _Arg, typename _NodeGenerator&gt;</span>
<span id="L2289"><span class="lineNum">    2289</span>              :       auto</span>
<span id="L2290"><span class="lineNum">    2290</span>              :       _Hashtable&lt;_Key, _Value, _Alloc, _ExtractKey, _Equal,</span>
<span id="L2291"><span class="lineNum">    2291</span>              :                  _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits&gt;::</span>
<span id="L2292"><span class="lineNum">    2292</span>              :       _M_insert(const_iterator __hint, _Arg&amp;&amp; __v,</span>
<span id="L2293"><span class="lineNum">    2293</span>              :                 const _NodeGenerator&amp; __node_gen,</span>
<span id="L2294"><span class="lineNum">    2294</span>              :                 false_type /* __uks */)</span>
<span id="L2295"><span class="lineNum">    2295</span>              :       -&gt; iterator</span>
<span id="L2296"><span class="lineNum">    2296</span>              :       {</span>
<span id="L2297"><span class="lineNum">    2297</span>              :         // First allocate new node so that we don't do anything if it throws.</span>
<span id="L2298"><span class="lineNum">    2298</span>              :         _Scoped_node __node{ __node_gen(std::forward&lt;_Arg&gt;(__v)), this };</span>
<span id="L2299"><span class="lineNum">    2299</span>              : </span>
<span id="L2300"><span class="lineNum">    2300</span>              :         // Second compute the hash code so that we don't rehash if it throws.</span>
<span id="L2301"><span class="lineNum">    2301</span>              :         auto __res = this-&gt;_M_compute_hash_code(</span>
<span id="L2302"><span class="lineNum">    2302</span>              :           __hint, _ExtractKey{}(__node._M_node-&gt;_M_v()));</span>
<span id="L2303"><span class="lineNum">    2303</span>              : </span>
<span id="L2304"><span class="lineNum">    2304</span>              :         auto __pos</span>
<span id="L2305"><span class="lineNum">    2305</span>              :           = _M_insert_multi_node(__res.first._M_cur, __res.second,</span>
<span id="L2306"><span class="lineNum">    2306</span>              :                                  __node._M_node);</span>
<span id="L2307"><span class="lineNum">    2307</span>              :         __node._M_node = nullptr;</span>
<span id="L2308"><span class="lineNum">    2308</span>              :         return __pos;</span>
<span id="L2309"><span class="lineNum">    2309</span>              :       }</span>
<span id="L2310"><span class="lineNum">    2310</span>              : </span>
<span id="L2311"><span class="lineNum">    2311</span>              :   template&lt;typename _Key, typename _Value, typename _Alloc,</span>
<span id="L2312"><span class="lineNum">    2312</span>              :            typename _ExtractKey, typename _Equal,</span>
<span id="L2313"><span class="lineNum">    2313</span>              :            typename _Hash, typename _RangeHash, typename _Unused,</span>
<span id="L2314"><span class="lineNum">    2314</span>              :            typename _RehashPolicy, typename _Traits&gt;</span>
<span id="L2315"><span class="lineNum">    2315</span>              :     auto</span>
<span id="L2316"><span class="lineNum">    2316</span>              :     _Hashtable&lt;_Key, _Value, _Alloc, _ExtractKey, _Equal,</span>
<span id="L2317"><span class="lineNum">    2317</span>              :                _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits&gt;::</span>
<span id="L2318"><span class="lineNum">    2318</span>              :     erase(const_iterator __it)</span>
<span id="L2319"><span class="lineNum">    2319</span>              :     -&gt; iterator</span>
<span id="L2320"><span class="lineNum">    2320</span>              :     {</span>
<span id="L2321"><span class="lineNum">    2321</span>              :       __node_ptr __n = __it._M_cur;</span>
<span id="L2322"><span class="lineNum">    2322</span>              :       std::size_t __bkt = _M_bucket_index(*__n);</span>
<span id="L2323"><span class="lineNum">    2323</span>              : </span>
<span id="L2324"><span class="lineNum">    2324</span>              :       // Look for previous node to unlink it from the erased one, this</span>
<span id="L2325"><span class="lineNum">    2325</span>              :       // is why we need buckets to contain the before begin to make</span>
<span id="L2326"><span class="lineNum">    2326</span>              :       // this search fast.</span>
<span id="L2327"><span class="lineNum">    2327</span>              :       __node_base_ptr __prev_n = _M_get_previous_node(__bkt, __n);</span>
<span id="L2328"><span class="lineNum">    2328</span>              :       return _M_erase(__bkt, __prev_n, __n);</span>
<span id="L2329"><span class="lineNum">    2329</span>              :     }</span>
<span id="L2330"><span class="lineNum">    2330</span>              : </span>
<span id="L2331"><span class="lineNum">    2331</span>              :   template&lt;typename _Key, typename _Value, typename _Alloc,</span>
<span id="L2332"><span class="lineNum">    2332</span>              :            typename _ExtractKey, typename _Equal,</span>
<span id="L2333"><span class="lineNum">    2333</span>              :            typename _Hash, typename _RangeHash, typename _Unused,</span>
<span id="L2334"><span class="lineNum">    2334</span>              :            typename _RehashPolicy, typename _Traits&gt;</span>
<span id="L2335"><span class="lineNum">    2335</span>              :     auto</span>
<span id="L2336"><span class="lineNum">    2336</span> <span class="tlaUNC tlaBgUNC">           0 :     _Hashtable&lt;_Key, _Value, _Alloc, _ExtractKey, _Equal,</span></span>
<span id="L2337"><span class="lineNum">    2337</span>              :                _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits&gt;::</span>
<span id="L2338"><span class="lineNum">    2338</span>              :     _M_erase(size_type __bkt, __node_base_ptr __prev_n, __node_ptr __n)</span>
<span id="L2339"><span class="lineNum">    2339</span>              :     -&gt; iterator</span>
<span id="L2340"><span class="lineNum">    2340</span>              :     {</span>
<span id="L2341"><span class="lineNum">    2341</span> <span class="tlaUNC">           0 :       if (__prev_n == _M_buckets[__bkt])</span></span>
<span id="L2342"><span class="lineNum">    2342</span> <span class="tlaUNC">           0 :         _M_remove_bucket_begin(__bkt, __n-&gt;_M_next(),</span></span>
<span id="L2343"><span class="lineNum">    2343</span> <span class="tlaUNC">           0 :           __n-&gt;_M_nxt ? _M_bucket_index(*__n-&gt;_M_next()) : 0);</span></span>
<span id="L2344"><span class="lineNum">    2344</span> <span class="tlaUNC">           0 :       else if (__n-&gt;_M_nxt)</span></span>
<span id="L2345"><span class="lineNum">    2345</span>              :         {</span>
<span id="L2346"><span class="lineNum">    2346</span> <span class="tlaUNC">           0 :           size_type __next_bkt = _M_bucket_index(*__n-&gt;_M_next());</span></span>
<span id="L2347"><span class="lineNum">    2347</span> <span class="tlaUNC">           0 :           if (__next_bkt != __bkt)</span></span>
<span id="L2348"><span class="lineNum">    2348</span> <span class="tlaUNC">           0 :             _M_buckets[__next_bkt] = __prev_n;</span></span>
<span id="L2349"><span class="lineNum">    2349</span>              :         }</span>
<span id="L2350"><span class="lineNum">    2350</span>              : </span>
<span id="L2351"><span class="lineNum">    2351</span> <span class="tlaUNC">           0 :       __prev_n-&gt;_M_nxt = __n-&gt;_M_nxt;</span></span>
<span id="L2352"><span class="lineNum">    2352</span> <span class="tlaUNC">           0 :       iterator __result(__n-&gt;_M_next());</span></span>
<span id="L2353"><span class="lineNum">    2353</span> <span class="tlaUNC">           0 :       this-&gt;_M_deallocate_node(__n);</span></span>
<span id="L2354"><span class="lineNum">    2354</span> <span class="tlaUNC">           0 :       --_M_element_count;</span></span>
<span id="L2355"><span class="lineNum">    2355</span>              : </span>
<span id="L2356"><span class="lineNum">    2356</span> <span class="tlaUNC">           0 :       return __result;</span></span>
<span id="L2357"><span class="lineNum">    2357</span>              :     }</span>
<span id="L2358"><span class="lineNum">    2358</span>              : </span>
<span id="L2359"><span class="lineNum">    2359</span>              :   template&lt;typename _Key, typename _Value, typename _Alloc,</span>
<span id="L2360"><span class="lineNum">    2360</span>              :            typename _ExtractKey, typename _Equal,</span>
<span id="L2361"><span class="lineNum">    2361</span>              :            typename _Hash, typename _RangeHash, typename _Unused,</span>
<span id="L2362"><span class="lineNum">    2362</span>              :            typename _RehashPolicy, typename _Traits&gt;</span>
<span id="L2363"><span class="lineNum">    2363</span>              :     auto</span>
<span id="L2364"><span class="lineNum">    2364</span> <span class="tlaUNC">           0 :     _Hashtable&lt;_Key, _Value, _Alloc, _ExtractKey, _Equal,</span></span>
<span id="L2365"><span class="lineNum">    2365</span>              :                _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits&gt;::</span>
<span id="L2366"><span class="lineNum">    2366</span>              :     _M_erase(true_type /* __uks */, const key_type&amp; __k)</span>
<span id="L2367"><span class="lineNum">    2367</span>              :     -&gt; size_type</span>
<span id="L2368"><span class="lineNum">    2368</span>              :     {</span>
<span id="L2369"><span class="lineNum">    2369</span>              :       __node_base_ptr __prev_n;</span>
<span id="L2370"><span class="lineNum">    2370</span>              :       __node_ptr __n;</span>
<span id="L2371"><span class="lineNum">    2371</span>              :       std::size_t __bkt;</span>
<span id="L2372"><span class="lineNum">    2372</span> <span class="tlaUNC">           0 :       if (size() &lt;= __small_size_threshold())</span></span>
<span id="L2373"><span class="lineNum">    2373</span>              :         {</span>
<span id="L2374"><span class="lineNum">    2374</span> <span class="tlaUNC">           0 :           __prev_n = _M_find_before_node(__k);</span></span>
<span id="L2375"><span class="lineNum">    2375</span> <span class="tlaUNC">           0 :           if (!__prev_n)</span></span>
<span id="L2376"><span class="lineNum">    2376</span> <span class="tlaUNC">           0 :             return 0;</span></span>
<span id="L2377"><span class="lineNum">    2377</span>              : </span>
<span id="L2378"><span class="lineNum">    2378</span>              :           // We found a matching node, erase it.</span>
<span id="L2379"><span class="lineNum">    2379</span> <span class="tlaUNC">           0 :           __n = static_cast&lt;__node_ptr&gt;(__prev_n-&gt;_M_nxt);</span></span>
<span id="L2380"><span class="lineNum">    2380</span> <span class="tlaUNC">           0 :           __bkt = _M_bucket_index(*__n);</span></span>
<span id="L2381"><span class="lineNum">    2381</span>              :         }</span>
<span id="L2382"><span class="lineNum">    2382</span>              :       else</span>
<span id="L2383"><span class="lineNum">    2383</span>              :         {</span>
<span id="L2384"><span class="lineNum">    2384</span> <span class="tlaUNC">           0 :           __hash_code __code = this-&gt;_M_hash_code(__k);</span></span>
<span id="L2385"><span class="lineNum">    2385</span> <span class="tlaUNC">           0 :           __bkt = _M_bucket_index(__code);</span></span>
<span id="L2386"><span class="lineNum">    2386</span>              : </span>
<span id="L2387"><span class="lineNum">    2387</span>              :           // Look for the node before the first matching node.</span>
<span id="L2388"><span class="lineNum">    2388</span> <span class="tlaUNC">           0 :           __prev_n = _M_find_before_node(__bkt, __k, __code);</span></span>
<span id="L2389"><span class="lineNum">    2389</span> <span class="tlaUNC">           0 :           if (!__prev_n)</span></span>
<span id="L2390"><span class="lineNum">    2390</span> <span class="tlaUNC">           0 :             return 0;</span></span>
<span id="L2391"><span class="lineNum">    2391</span>              : </span>
<span id="L2392"><span class="lineNum">    2392</span>              :           // We found a matching node, erase it.</span>
<span id="L2393"><span class="lineNum">    2393</span> <span class="tlaUNC">           0 :           __n = static_cast&lt;__node_ptr&gt;(__prev_n-&gt;_M_nxt);</span></span>
<span id="L2394"><span class="lineNum">    2394</span>              :         }</span>
<span id="L2395"><span class="lineNum">    2395</span>              : </span>
<span id="L2396"><span class="lineNum">    2396</span> <span class="tlaUNC">           0 :       _M_erase(__bkt, __prev_n, __n);</span></span>
<span id="L2397"><span class="lineNum">    2397</span> <span class="tlaUNC">           0 :       return 1;</span></span>
<span id="L2398"><span class="lineNum">    2398</span>              :     }</span>
<span id="L2399"><span class="lineNum">    2399</span>              : </span>
<span id="L2400"><span class="lineNum">    2400</span>              :   template&lt;typename _Key, typename _Value, typename _Alloc,</span>
<span id="L2401"><span class="lineNum">    2401</span>              :            typename _ExtractKey, typename _Equal,</span>
<span id="L2402"><span class="lineNum">    2402</span>              :            typename _Hash, typename _RangeHash, typename _Unused,</span>
<span id="L2403"><span class="lineNum">    2403</span>              :            typename _RehashPolicy, typename _Traits&gt;</span>
<span id="L2404"><span class="lineNum">    2404</span>              :     auto</span>
<span id="L2405"><span class="lineNum">    2405</span>              :     _Hashtable&lt;_Key, _Value, _Alloc, _ExtractKey, _Equal,</span>
<span id="L2406"><span class="lineNum">    2406</span>              :                _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits&gt;::</span>
<span id="L2407"><span class="lineNum">    2407</span>              :     _M_erase(false_type /* __uks */, const key_type&amp; __k)</span>
<span id="L2408"><span class="lineNum">    2408</span>              :     -&gt; size_type</span>
<span id="L2409"><span class="lineNum">    2409</span>              :     {</span>
<span id="L2410"><span class="lineNum">    2410</span>              :       std::size_t __bkt;</span>
<span id="L2411"><span class="lineNum">    2411</span>              :       __node_base_ptr __prev_n;</span>
<span id="L2412"><span class="lineNum">    2412</span>              :       __node_ptr __n;</span>
<span id="L2413"><span class="lineNum">    2413</span>              :       if (size() &lt;= __small_size_threshold())</span>
<span id="L2414"><span class="lineNum">    2414</span>              :         {</span>
<span id="L2415"><span class="lineNum">    2415</span>              :           __prev_n = _M_find_before_node(__k);</span>
<span id="L2416"><span class="lineNum">    2416</span>              :           if (!__prev_n)</span>
<span id="L2417"><span class="lineNum">    2417</span>              :             return 0;</span>
<span id="L2418"><span class="lineNum">    2418</span>              : </span>
<span id="L2419"><span class="lineNum">    2419</span>              :           // We found a matching node, erase it.</span>
<span id="L2420"><span class="lineNum">    2420</span>              :           __n = static_cast&lt;__node_ptr&gt;(__prev_n-&gt;_M_nxt);</span>
<span id="L2421"><span class="lineNum">    2421</span>              :           __bkt = _M_bucket_index(*__n);</span>
<span id="L2422"><span class="lineNum">    2422</span>              :         }</span>
<span id="L2423"><span class="lineNum">    2423</span>              :       else</span>
<span id="L2424"><span class="lineNum">    2424</span>              :         {</span>
<span id="L2425"><span class="lineNum">    2425</span>              :           __hash_code __code = this-&gt;_M_hash_code(__k);</span>
<span id="L2426"><span class="lineNum">    2426</span>              :           __bkt = _M_bucket_index(__code);</span>
<span id="L2427"><span class="lineNum">    2427</span>              : </span>
<span id="L2428"><span class="lineNum">    2428</span>              :           // Look for the node before the first matching node.</span>
<span id="L2429"><span class="lineNum">    2429</span>              :           __prev_n = _M_find_before_node(__bkt, __k, __code);</span>
<span id="L2430"><span class="lineNum">    2430</span>              :           if (!__prev_n)</span>
<span id="L2431"><span class="lineNum">    2431</span>              :             return 0;</span>
<span id="L2432"><span class="lineNum">    2432</span>              : </span>
<span id="L2433"><span class="lineNum">    2433</span>              :           __n = static_cast&lt;__node_ptr&gt;(__prev_n-&gt;_M_nxt);</span>
<span id="L2434"><span class="lineNum">    2434</span>              :         }</span>
<span id="L2435"><span class="lineNum">    2435</span>              : </span>
<span id="L2436"><span class="lineNum">    2436</span>              :       // _GLIBCXX_RESOLVE_LIB_DEFECTS</span>
<span id="L2437"><span class="lineNum">    2437</span>              :       // 526. Is it undefined if a function in the standard changes</span>
<span id="L2438"><span class="lineNum">    2438</span>              :       // in parameters?</span>
<span id="L2439"><span class="lineNum">    2439</span>              :       // We use one loop to find all matching nodes and another to deallocate</span>
<span id="L2440"><span class="lineNum">    2440</span>              :       // them so that the key stays valid during the first loop. It might be</span>
<span id="L2441"><span class="lineNum">    2441</span>              :       // invalidated indirectly when destroying nodes.</span>
<span id="L2442"><span class="lineNum">    2442</span>              :       __node_ptr __n_last = __n-&gt;_M_next();</span>
<span id="L2443"><span class="lineNum">    2443</span>              :       while (__n_last &amp;&amp; this-&gt;_M_node_equals(*__n, *__n_last))</span>
<span id="L2444"><span class="lineNum">    2444</span>              :         __n_last = __n_last-&gt;_M_next();</span>
<span id="L2445"><span class="lineNum">    2445</span>              : </span>
<span id="L2446"><span class="lineNum">    2446</span>              :       std::size_t __n_last_bkt = __n_last ? _M_bucket_index(*__n_last) : __bkt;</span>
<span id="L2447"><span class="lineNum">    2447</span>              : </span>
<span id="L2448"><span class="lineNum">    2448</span>              :       // Deallocate nodes.</span>
<span id="L2449"><span class="lineNum">    2449</span>              :       size_type __result = 0;</span>
<span id="L2450"><span class="lineNum">    2450</span>              :       do</span>
<span id="L2451"><span class="lineNum">    2451</span>              :         {</span>
<span id="L2452"><span class="lineNum">    2452</span>              :           __node_ptr __p = __n-&gt;_M_next();</span>
<span id="L2453"><span class="lineNum">    2453</span>              :           this-&gt;_M_deallocate_node(__n);</span>
<span id="L2454"><span class="lineNum">    2454</span>              :           __n = __p;</span>
<span id="L2455"><span class="lineNum">    2455</span>              :           ++__result;</span>
<span id="L2456"><span class="lineNum">    2456</span>              :         }</span>
<span id="L2457"><span class="lineNum">    2457</span>              :       while (__n != __n_last);</span>
<span id="L2458"><span class="lineNum">    2458</span>              : </span>
<span id="L2459"><span class="lineNum">    2459</span>              :       _M_element_count -= __result;</span>
<span id="L2460"><span class="lineNum">    2460</span>              :       if (__prev_n == _M_buckets[__bkt])</span>
<span id="L2461"><span class="lineNum">    2461</span>              :         _M_remove_bucket_begin(__bkt, __n_last, __n_last_bkt);</span>
<span id="L2462"><span class="lineNum">    2462</span>              :       else if (__n_last_bkt != __bkt)</span>
<span id="L2463"><span class="lineNum">    2463</span>              :         _M_buckets[__n_last_bkt] = __prev_n;</span>
<span id="L2464"><span class="lineNum">    2464</span>              :       __prev_n-&gt;_M_nxt = __n_last;</span>
<span id="L2465"><span class="lineNum">    2465</span>              :       return __result;</span>
<span id="L2466"><span class="lineNum">    2466</span>              :     }</span>
<span id="L2467"><span class="lineNum">    2467</span>              : </span>
<span id="L2468"><span class="lineNum">    2468</span>              :   template&lt;typename _Key, typename _Value, typename _Alloc,</span>
<span id="L2469"><span class="lineNum">    2469</span>              :            typename _ExtractKey, typename _Equal,</span>
<span id="L2470"><span class="lineNum">    2470</span>              :            typename _Hash, typename _RangeHash, typename _Unused,</span>
<span id="L2471"><span class="lineNum">    2471</span>              :            typename _RehashPolicy, typename _Traits&gt;</span>
<span id="L2472"><span class="lineNum">    2472</span>              :     auto</span>
<span id="L2473"><span class="lineNum">    2473</span>              :     _Hashtable&lt;_Key, _Value, _Alloc, _ExtractKey, _Equal,</span>
<span id="L2474"><span class="lineNum">    2474</span>              :                _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits&gt;::</span>
<span id="L2475"><span class="lineNum">    2475</span>              :     erase(const_iterator __first, const_iterator __last)</span>
<span id="L2476"><span class="lineNum">    2476</span>              :     -&gt; iterator</span>
<span id="L2477"><span class="lineNum">    2477</span>              :     {</span>
<span id="L2478"><span class="lineNum">    2478</span>              :       __node_ptr __n = __first._M_cur;</span>
<span id="L2479"><span class="lineNum">    2479</span>              :       __node_ptr __last_n = __last._M_cur;</span>
<span id="L2480"><span class="lineNum">    2480</span>              :       if (__n == __last_n)</span>
<span id="L2481"><span class="lineNum">    2481</span>              :         return iterator(__n);</span>
<span id="L2482"><span class="lineNum">    2482</span>              : </span>
<span id="L2483"><span class="lineNum">    2483</span>              :       std::size_t __bkt = _M_bucket_index(*__n);</span>
<span id="L2484"><span class="lineNum">    2484</span>              : </span>
<span id="L2485"><span class="lineNum">    2485</span>              :       __node_base_ptr __prev_n = _M_get_previous_node(__bkt, __n);</span>
<span id="L2486"><span class="lineNum">    2486</span>              :       bool __is_bucket_begin = __n == _M_bucket_begin(__bkt);</span>
<span id="L2487"><span class="lineNum">    2487</span>              :       std::size_t __n_bkt = __bkt;</span>
<span id="L2488"><span class="lineNum">    2488</span>              :       for (;;)</span>
<span id="L2489"><span class="lineNum">    2489</span>              :         {</span>
<span id="L2490"><span class="lineNum">    2490</span>              :           do</span>
<span id="L2491"><span class="lineNum">    2491</span>              :             {</span>
<span id="L2492"><span class="lineNum">    2492</span>              :               __node_ptr __tmp = __n;</span>
<span id="L2493"><span class="lineNum">    2493</span>              :               __n = __n-&gt;_M_next();</span>
<span id="L2494"><span class="lineNum">    2494</span>              :               this-&gt;_M_deallocate_node(__tmp);</span>
<span id="L2495"><span class="lineNum">    2495</span>              :               --_M_element_count;</span>
<span id="L2496"><span class="lineNum">    2496</span>              :               if (!__n)</span>
<span id="L2497"><span class="lineNum">    2497</span>              :                 break;</span>
<span id="L2498"><span class="lineNum">    2498</span>              :               __n_bkt = _M_bucket_index(*__n);</span>
<span id="L2499"><span class="lineNum">    2499</span>              :             }</span>
<span id="L2500"><span class="lineNum">    2500</span>              :           while (__n != __last_n &amp;&amp; __n_bkt == __bkt);</span>
<span id="L2501"><span class="lineNum">    2501</span>              :           if (__is_bucket_begin)</span>
<span id="L2502"><span class="lineNum">    2502</span>              :             _M_remove_bucket_begin(__bkt, __n, __n_bkt);</span>
<span id="L2503"><span class="lineNum">    2503</span>              :           if (__n == __last_n)</span>
<span id="L2504"><span class="lineNum">    2504</span>              :             break;</span>
<span id="L2505"><span class="lineNum">    2505</span>              :           __is_bucket_begin = true;</span>
<span id="L2506"><span class="lineNum">    2506</span>              :           __bkt = __n_bkt;</span>
<span id="L2507"><span class="lineNum">    2507</span>              :         }</span>
<span id="L2508"><span class="lineNum">    2508</span>              : </span>
<span id="L2509"><span class="lineNum">    2509</span>              :       if (__n &amp;&amp; (__n_bkt != __bkt || __is_bucket_begin))</span>
<span id="L2510"><span class="lineNum">    2510</span>              :         _M_buckets[__n_bkt] = __prev_n;</span>
<span id="L2511"><span class="lineNum">    2511</span>              :       __prev_n-&gt;_M_nxt = __n;</span>
<span id="L2512"><span class="lineNum">    2512</span>              :       return iterator(__n);</span>
<span id="L2513"><span class="lineNum">    2513</span>              :     }</span>
<span id="L2514"><span class="lineNum">    2514</span>              : </span>
<span id="L2515"><span class="lineNum">    2515</span>              :   template&lt;typename _Key, typename _Value, typename _Alloc,</span>
<span id="L2516"><span class="lineNum">    2516</span>              :            typename _ExtractKey, typename _Equal,</span>
<span id="L2517"><span class="lineNum">    2517</span>              :            typename _Hash, typename _RangeHash, typename _Unused,</span>
<span id="L2518"><span class="lineNum">    2518</span>              :            typename _RehashPolicy, typename _Traits&gt;</span>
<span id="L2519"><span class="lineNum">    2519</span>              :     void</span>
<span id="L2520"><span class="lineNum">    2520</span> <span class="tlaGNC tlaBgGNC">           2 :     _Hashtable&lt;_Key, _Value, _Alloc, _ExtractKey, _Equal,</span></span>
<span id="L2521"><span class="lineNum">    2521</span>              :                _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits&gt;::</span>
<span id="L2522"><span class="lineNum">    2522</span>              :     clear() noexcept</span>
<span id="L2523"><span class="lineNum">    2523</span>              :     {</span>
<span id="L2524"><span class="lineNum">    2524</span> <span class="tlaGNC">           2 :       this-&gt;_M_deallocate_nodes(_M_begin());</span></span>
<span id="L2525"><span class="lineNum">    2525</span> <span class="tlaGNC">           2 :       __builtin_memset(_M_buckets, 0,</span></span>
<span id="L2526"><span class="lineNum">    2526</span> <span class="tlaGNC">           2 :                        _M_bucket_count * sizeof(__node_base_ptr));</span></span>
<span id="L2527"><span class="lineNum">    2527</span> <span class="tlaGNC">           2 :       _M_element_count = 0;</span></span>
<span id="L2528"><span class="lineNum">    2528</span> <span class="tlaGNC">           2 :       _M_before_begin._M_nxt = nullptr;</span></span>
<span id="L2529"><span class="lineNum">    2529</span> <span class="tlaGNC">           2 :     }</span></span>
<span id="L2530"><span class="lineNum">    2530</span>              : </span>
<span id="L2531"><span class="lineNum">    2531</span>              :   template&lt;typename _Key, typename _Value, typename _Alloc,</span>
<span id="L2532"><span class="lineNum">    2532</span>              :            typename _ExtractKey, typename _Equal,</span>
<span id="L2533"><span class="lineNum">    2533</span>              :            typename _Hash, typename _RangeHash, typename _Unused,</span>
<span id="L2534"><span class="lineNum">    2534</span>              :            typename _RehashPolicy, typename _Traits&gt;</span>
<span id="L2535"><span class="lineNum">    2535</span>              :     void</span>
<span id="L2536"><span class="lineNum">    2536</span>              :     _Hashtable&lt;_Key, _Value, _Alloc, _ExtractKey, _Equal,</span>
<span id="L2537"><span class="lineNum">    2537</span>              :                _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits&gt;::</span>
<span id="L2538"><span class="lineNum">    2538</span>              :     rehash(size_type __bkt_count)</span>
<span id="L2539"><span class="lineNum">    2539</span>              :     {</span>
<span id="L2540"><span class="lineNum">    2540</span>              :       const __rehash_state&amp; __saved_state = _M_rehash_policy._M_state();</span>
<span id="L2541"><span class="lineNum">    2541</span>              :       __bkt_count</span>
<span id="L2542"><span class="lineNum">    2542</span>              :         = std::max(_M_rehash_policy._M_bkt_for_elements(_M_element_count + 1),</span>
<span id="L2543"><span class="lineNum">    2543</span>              :                    __bkt_count);</span>
<span id="L2544"><span class="lineNum">    2544</span>              :       __bkt_count = _M_rehash_policy._M_next_bkt(__bkt_count);</span>
<span id="L2545"><span class="lineNum">    2545</span>              : </span>
<span id="L2546"><span class="lineNum">    2546</span>              :       if (__bkt_count != _M_bucket_count)</span>
<span id="L2547"><span class="lineNum">    2547</span>              :         _M_rehash(__bkt_count, __saved_state);</span>
<span id="L2548"><span class="lineNum">    2548</span>              :       else</span>
<span id="L2549"><span class="lineNum">    2549</span>              :         // No rehash, restore previous state to keep it consistent with</span>
<span id="L2550"><span class="lineNum">    2550</span>              :         // container state.</span>
<span id="L2551"><span class="lineNum">    2551</span>              :         _M_rehash_policy._M_reset(__saved_state);</span>
<span id="L2552"><span class="lineNum">    2552</span>              :     }</span>
<span id="L2553"><span class="lineNum">    2553</span>              : </span>
<span id="L2554"><span class="lineNum">    2554</span>              :   template&lt;typename _Key, typename _Value, typename _Alloc,</span>
<span id="L2555"><span class="lineNum">    2555</span>              :            typename _ExtractKey, typename _Equal,</span>
<span id="L2556"><span class="lineNum">    2556</span>              :            typename _Hash, typename _RangeHash, typename _Unused,</span>
<span id="L2557"><span class="lineNum">    2557</span>              :            typename _RehashPolicy, typename _Traits&gt;</span>
<span id="L2558"><span class="lineNum">    2558</span>              :     void</span>
<span id="L2559"><span class="lineNum">    2559</span> <span class="tlaGNC">           2 :     _Hashtable&lt;_Key, _Value, _Alloc, _ExtractKey, _Equal,</span></span>
<span id="L2560"><span class="lineNum">    2560</span>              :                _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits&gt;::</span>
<span id="L2561"><span class="lineNum">    2561</span>              :     _M_rehash(size_type __bkt_count, const __rehash_state&amp; __state)</span>
<span id="L2562"><span class="lineNum">    2562</span>              :     {</span>
<span id="L2563"><span class="lineNum">    2563</span>              :       __try</span>
<span id="L2564"><span class="lineNum">    2564</span>              :         {</span>
<span id="L2565"><span class="lineNum">    2565</span> <span class="tlaGNC">           2 :           _M_rehash_aux(__bkt_count, __unique_keys{});</span></span>
<span id="L2566"><span class="lineNum">    2566</span>              :         }</span>
<span id="L2567"><span class="lineNum">    2567</span> <span class="tlaUNC tlaBgUNC">           0 :       __catch(...)</span></span>
<span id="L2568"><span class="lineNum">    2568</span>              :         {</span>
<span id="L2569"><span class="lineNum">    2569</span>              :           // A failure here means that buckets allocation failed.  We only</span>
<span id="L2570"><span class="lineNum">    2570</span>              :           // have to restore hash policy previous state.</span>
<span id="L2571"><span class="lineNum">    2571</span> <span class="tlaUNC">           0 :           _M_rehash_policy._M_reset(__state);</span></span>
<span id="L2572"><span class="lineNum">    2572</span> <span class="tlaUNC">           0 :           __throw_exception_again;</span></span>
<span id="L2573"><span class="lineNum">    2573</span>              :         }</span>
<span id="L2574"><span class="lineNum">    2574</span> <span class="tlaGNC tlaBgGNC">           2 :     }</span></span>
<span id="L2575"><span class="lineNum">    2575</span>              : </span>
<span id="L2576"><span class="lineNum">    2576</span>              :   // Rehash when there is no equivalent elements.</span>
<span id="L2577"><span class="lineNum">    2577</span>              :   template&lt;typename _Key, typename _Value, typename _Alloc,</span>
<span id="L2578"><span class="lineNum">    2578</span>              :            typename _ExtractKey, typename _Equal,</span>
<span id="L2579"><span class="lineNum">    2579</span>              :            typename _Hash, typename _RangeHash, typename _Unused,</span>
<span id="L2580"><span class="lineNum">    2580</span>              :            typename _RehashPolicy, typename _Traits&gt;</span>
<span id="L2581"><span class="lineNum">    2581</span>              :     void</span>
<span id="L2582"><span class="lineNum">    2582</span> <span class="tlaGNC">           2 :     _Hashtable&lt;_Key, _Value, _Alloc, _ExtractKey, _Equal,</span></span>
<span id="L2583"><span class="lineNum">    2583</span>              :                _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits&gt;::</span>
<span id="L2584"><span class="lineNum">    2584</span>              :     _M_rehash_aux(size_type __bkt_count, true_type /* __uks */)</span>
<span id="L2585"><span class="lineNum">    2585</span>              :     {</span>
<span id="L2586"><span class="lineNum">    2586</span> <span class="tlaGNC">           2 :       __buckets_ptr __new_buckets = _M_allocate_buckets(__bkt_count);</span></span>
<span id="L2587"><span class="lineNum">    2587</span> <span class="tlaGNC">           2 :       __node_ptr __p = _M_begin();</span></span>
<span id="L2588"><span class="lineNum">    2588</span> <span class="tlaGNC">           2 :       _M_before_begin._M_nxt = nullptr;</span></span>
<span id="L2589"><span class="lineNum">    2589</span> <span class="tlaGNC">           2 :       std::size_t __bbegin_bkt = 0;</span></span>
<span id="L2590"><span class="lineNum">    2590</span> <span class="tlaGNC">           2 :       while (__p)</span></span>
<span id="L2591"><span class="lineNum">    2591</span>              :         {</span>
<span id="L2592"><span class="lineNum">    2592</span> <span class="tlaUNC tlaBgUNC">           0 :           __node_ptr __next = __p-&gt;_M_next();</span></span>
<span id="L2593"><span class="lineNum">    2593</span>              :           std::size_t __bkt</span>
<span id="L2594"><span class="lineNum">    2594</span> <span class="tlaUNC">           0 :             = __hash_code_base::_M_bucket_index(*__p, __bkt_count);</span></span>
<span id="L2595"><span class="lineNum">    2595</span> <span class="tlaUNC">           0 :           if (!__new_buckets[__bkt])</span></span>
<span id="L2596"><span class="lineNum">    2596</span>              :             {</span>
<span id="L2597"><span class="lineNum">    2597</span> <span class="tlaUNC">           0 :               __p-&gt;_M_nxt = _M_before_begin._M_nxt;</span></span>
<span id="L2598"><span class="lineNum">    2598</span> <span class="tlaUNC">           0 :               _M_before_begin._M_nxt = __p;</span></span>
<span id="L2599"><span class="lineNum">    2599</span> <span class="tlaUNC">           0 :               __new_buckets[__bkt] = &amp;_M_before_begin;</span></span>
<span id="L2600"><span class="lineNum">    2600</span> <span class="tlaUNC">           0 :               if (__p-&gt;_M_nxt)</span></span>
<span id="L2601"><span class="lineNum">    2601</span> <span class="tlaUNC">           0 :                 __new_buckets[__bbegin_bkt] = __p;</span></span>
<span id="L2602"><span class="lineNum">    2602</span> <span class="tlaUNC">           0 :               __bbegin_bkt = __bkt;</span></span>
<span id="L2603"><span class="lineNum">    2603</span>              :             }</span>
<span id="L2604"><span class="lineNum">    2604</span>              :           else</span>
<span id="L2605"><span class="lineNum">    2605</span>              :             {</span>
<span id="L2606"><span class="lineNum">    2606</span> <span class="tlaUNC">           0 :               __p-&gt;_M_nxt = __new_buckets[__bkt]-&gt;_M_nxt;</span></span>
<span id="L2607"><span class="lineNum">    2607</span> <span class="tlaUNC">           0 :               __new_buckets[__bkt]-&gt;_M_nxt = __p;</span></span>
<span id="L2608"><span class="lineNum">    2608</span>              :             }</span>
<span id="L2609"><span class="lineNum">    2609</span>              : </span>
<span id="L2610"><span class="lineNum">    2610</span> <span class="tlaUNC">           0 :           __p = __next;</span></span>
<span id="L2611"><span class="lineNum">    2611</span>              :         }</span>
<span id="L2612"><span class="lineNum">    2612</span>              : </span>
<span id="L2613"><span class="lineNum">    2613</span> <span class="tlaGNC tlaBgGNC">           2 :       _M_deallocate_buckets();</span></span>
<span id="L2614"><span class="lineNum">    2614</span> <span class="tlaGNC">           2 :       _M_bucket_count = __bkt_count;</span></span>
<span id="L2615"><span class="lineNum">    2615</span> <span class="tlaGNC">           2 :       _M_buckets = __new_buckets;</span></span>
<span id="L2616"><span class="lineNum">    2616</span> <span class="tlaGNC">           2 :     }</span></span>
<span id="L2617"><span class="lineNum">    2617</span>              : </span>
<span id="L2618"><span class="lineNum">    2618</span>              :   // Rehash when there can be equivalent elements, preserve their relative</span>
<span id="L2619"><span class="lineNum">    2619</span>              :   // order.</span>
<span id="L2620"><span class="lineNum">    2620</span>              :   template&lt;typename _Key, typename _Value, typename _Alloc,</span>
<span id="L2621"><span class="lineNum">    2621</span>              :            typename _ExtractKey, typename _Equal,</span>
<span id="L2622"><span class="lineNum">    2622</span>              :            typename _Hash, typename _RangeHash, typename _Unused,</span>
<span id="L2623"><span class="lineNum">    2623</span>              :            typename _RehashPolicy, typename _Traits&gt;</span>
<span id="L2624"><span class="lineNum">    2624</span>              :     void</span>
<span id="L2625"><span class="lineNum">    2625</span>              :     _Hashtable&lt;_Key, _Value, _Alloc, _ExtractKey, _Equal,</span>
<span id="L2626"><span class="lineNum">    2626</span>              :                _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits&gt;::</span>
<span id="L2627"><span class="lineNum">    2627</span>              :     _M_rehash_aux(size_type __bkt_count, false_type /* __uks */)</span>
<span id="L2628"><span class="lineNum">    2628</span>              :     {</span>
<span id="L2629"><span class="lineNum">    2629</span>              :       __buckets_ptr __new_buckets = _M_allocate_buckets(__bkt_count);</span>
<span id="L2630"><span class="lineNum">    2630</span>              :       __node_ptr __p = _M_begin();</span>
<span id="L2631"><span class="lineNum">    2631</span>              :       _M_before_begin._M_nxt = nullptr;</span>
<span id="L2632"><span class="lineNum">    2632</span>              :       std::size_t __bbegin_bkt = 0;</span>
<span id="L2633"><span class="lineNum">    2633</span>              :       std::size_t __prev_bkt = 0;</span>
<span id="L2634"><span class="lineNum">    2634</span>              :       __node_ptr __prev_p = nullptr;</span>
<span id="L2635"><span class="lineNum">    2635</span>              :       bool __check_bucket = false;</span>
<span id="L2636"><span class="lineNum">    2636</span>              : </span>
<span id="L2637"><span class="lineNum">    2637</span>              :       while (__p)</span>
<span id="L2638"><span class="lineNum">    2638</span>              :         {</span>
<span id="L2639"><span class="lineNum">    2639</span>              :           __node_ptr __next = __p-&gt;_M_next();</span>
<span id="L2640"><span class="lineNum">    2640</span>              :           std::size_t __bkt</span>
<span id="L2641"><span class="lineNum">    2641</span>              :             = __hash_code_base::_M_bucket_index(*__p, __bkt_count);</span>
<span id="L2642"><span class="lineNum">    2642</span>              : </span>
<span id="L2643"><span class="lineNum">    2643</span>              :           if (__prev_p &amp;&amp; __prev_bkt == __bkt)</span>
<span id="L2644"><span class="lineNum">    2644</span>              :             {</span>
<span id="L2645"><span class="lineNum">    2645</span>              :               // Previous insert was already in this bucket, we insert after</span>
<span id="L2646"><span class="lineNum">    2646</span>              :               // the previously inserted one to preserve equivalent elements</span>
<span id="L2647"><span class="lineNum">    2647</span>              :               // relative order.</span>
<span id="L2648"><span class="lineNum">    2648</span>              :               __p-&gt;_M_nxt = __prev_p-&gt;_M_nxt;</span>
<span id="L2649"><span class="lineNum">    2649</span>              :               __prev_p-&gt;_M_nxt = __p;</span>
<span id="L2650"><span class="lineNum">    2650</span>              : </span>
<span id="L2651"><span class="lineNum">    2651</span>              :               // Inserting after a node in a bucket require to check that we</span>
<span id="L2652"><span class="lineNum">    2652</span>              :               // haven't change the bucket last node, in this case next</span>
<span id="L2653"><span class="lineNum">    2653</span>              :               // bucket containing its before begin node must be updated. We</span>
<span id="L2654"><span class="lineNum">    2654</span>              :               // schedule a check as soon as we move out of the sequence of</span>
<span id="L2655"><span class="lineNum">    2655</span>              :               // equivalent nodes to limit the number of checks.</span>
<span id="L2656"><span class="lineNum">    2656</span>              :               __check_bucket = true;</span>
<span id="L2657"><span class="lineNum">    2657</span>              :             }</span>
<span id="L2658"><span class="lineNum">    2658</span>              :           else</span>
<span id="L2659"><span class="lineNum">    2659</span>              :             {</span>
<span id="L2660"><span class="lineNum">    2660</span>              :               if (__check_bucket)</span>
<span id="L2661"><span class="lineNum">    2661</span>              :                 {</span>
<span id="L2662"><span class="lineNum">    2662</span>              :                   // Check if we shall update the next bucket because of</span>
<span id="L2663"><span class="lineNum">    2663</span>              :                   // insertions into __prev_bkt bucket.</span>
<span id="L2664"><span class="lineNum">    2664</span>              :                   if (__prev_p-&gt;_M_nxt)</span>
<span id="L2665"><span class="lineNum">    2665</span>              :                     {</span>
<span id="L2666"><span class="lineNum">    2666</span>              :                       std::size_t __next_bkt</span>
<span id="L2667"><span class="lineNum">    2667</span>              :                         = __hash_code_base::_M_bucket_index(</span>
<span id="L2668"><span class="lineNum">    2668</span>              :                           *__prev_p-&gt;_M_next(), __bkt_count);</span>
<span id="L2669"><span class="lineNum">    2669</span>              :                       if (__next_bkt != __prev_bkt)</span>
<span id="L2670"><span class="lineNum">    2670</span>              :                         __new_buckets[__next_bkt] = __prev_p;</span>
<span id="L2671"><span class="lineNum">    2671</span>              :                     }</span>
<span id="L2672"><span class="lineNum">    2672</span>              :                   __check_bucket = false;</span>
<span id="L2673"><span class="lineNum">    2673</span>              :                 }</span>
<span id="L2674"><span class="lineNum">    2674</span>              : </span>
<span id="L2675"><span class="lineNum">    2675</span>              :               if (!__new_buckets[__bkt])</span>
<span id="L2676"><span class="lineNum">    2676</span>              :                 {</span>
<span id="L2677"><span class="lineNum">    2677</span>              :                   __p-&gt;_M_nxt = _M_before_begin._M_nxt;</span>
<span id="L2678"><span class="lineNum">    2678</span>              :                   _M_before_begin._M_nxt = __p;</span>
<span id="L2679"><span class="lineNum">    2679</span>              :                   __new_buckets[__bkt] = &amp;_M_before_begin;</span>
<span id="L2680"><span class="lineNum">    2680</span>              :                   if (__p-&gt;_M_nxt)</span>
<span id="L2681"><span class="lineNum">    2681</span>              :                     __new_buckets[__bbegin_bkt] = __p;</span>
<span id="L2682"><span class="lineNum">    2682</span>              :                   __bbegin_bkt = __bkt;</span>
<span id="L2683"><span class="lineNum">    2683</span>              :                 }</span>
<span id="L2684"><span class="lineNum">    2684</span>              :               else</span>
<span id="L2685"><span class="lineNum">    2685</span>              :                 {</span>
<span id="L2686"><span class="lineNum">    2686</span>              :                   __p-&gt;_M_nxt = __new_buckets[__bkt]-&gt;_M_nxt;</span>
<span id="L2687"><span class="lineNum">    2687</span>              :                   __new_buckets[__bkt]-&gt;_M_nxt = __p;</span>
<span id="L2688"><span class="lineNum">    2688</span>              :                 }</span>
<span id="L2689"><span class="lineNum">    2689</span>              :             }</span>
<span id="L2690"><span class="lineNum">    2690</span>              :           __prev_p = __p;</span>
<span id="L2691"><span class="lineNum">    2691</span>              :           __prev_bkt = __bkt;</span>
<span id="L2692"><span class="lineNum">    2692</span>              :           __p = __next;</span>
<span id="L2693"><span class="lineNum">    2693</span>              :         }</span>
<span id="L2694"><span class="lineNum">    2694</span>              : </span>
<span id="L2695"><span class="lineNum">    2695</span>              :       if (__check_bucket &amp;&amp; __prev_p-&gt;_M_nxt)</span>
<span id="L2696"><span class="lineNum">    2696</span>              :         {</span>
<span id="L2697"><span class="lineNum">    2697</span>              :           std::size_t __next_bkt</span>
<span id="L2698"><span class="lineNum">    2698</span>              :             = __hash_code_base::_M_bucket_index(*__prev_p-&gt;_M_next(),</span>
<span id="L2699"><span class="lineNum">    2699</span>              :                                                 __bkt_count);</span>
<span id="L2700"><span class="lineNum">    2700</span>              :           if (__next_bkt != __prev_bkt)</span>
<span id="L2701"><span class="lineNum">    2701</span>              :             __new_buckets[__next_bkt] = __prev_p;</span>
<span id="L2702"><span class="lineNum">    2702</span>              :         }</span>
<span id="L2703"><span class="lineNum">    2703</span>              : </span>
<span id="L2704"><span class="lineNum">    2704</span>              :       _M_deallocate_buckets();</span>
<span id="L2705"><span class="lineNum">    2705</span>              :       _M_bucket_count = __bkt_count;</span>
<span id="L2706"><span class="lineNum">    2706</span>              :       _M_buckets = __new_buckets;</span>
<span id="L2707"><span class="lineNum">    2707</span>              :     }</span>
<span id="L2708"><span class="lineNum">    2708</span>              : </span>
<span id="L2709"><span class="lineNum">    2709</span>              : #if __cplusplus &gt; 201402L</span>
<span id="L2710"><span class="lineNum">    2710</span>              :   template&lt;typename, typename, typename&gt; class _Hash_merge_helper { };</span>
<span id="L2711"><span class="lineNum">    2711</span>              : #endif // C++17</span>
<span id="L2712"><span class="lineNum">    2712</span>              : </span>
<span id="L2713"><span class="lineNum">    2713</span>              : #if __cpp_deduction_guides &gt;= 201606</span>
<span id="L2714"><span class="lineNum">    2714</span>              :   // Used to constrain deduction guides</span>
<span id="L2715"><span class="lineNum">    2715</span>              :   template&lt;typename _Hash&gt;</span>
<span id="L2716"><span class="lineNum">    2716</span>              :     using _RequireNotAllocatorOrIntegral</span>
<span id="L2717"><span class="lineNum">    2717</span>              :       = __enable_if_t&lt;!__or_&lt;is_integral&lt;_Hash&gt;, __is_allocator&lt;_Hash&gt;&gt;::value&gt;;</span>
<span id="L2718"><span class="lineNum">    2718</span>              : #endif</span>
<span id="L2719"><span class="lineNum">    2719</span>              : </span>
<span id="L2720"><span class="lineNum">    2720</span>              : /// @endcond</span>
<span id="L2721"><span class="lineNum">    2721</span>              : _GLIBCXX_END_NAMESPACE_VERSION</span>
<span id="L2722"><span class="lineNum">    2722</span>              : } // namespace std</span>
<span id="L2723"><span class="lineNum">    2723</span>              : </span>
<span id="L2724"><span class="lineNum">    2724</span>              : #endif // _HASHTABLE_H</span>
        </pre>
              </td>
            </tr>
          </table>
          <br>

          <table width="100%" border=0 cellspacing=0 cellpadding=0>
            <tr><td class="ruler"><img src="../../glass.png" width=3 height=3 alt=""></td></tr>
            <tr><td class="versionInfo">Generated by: <a href="https://github.com//linux-test-project/lcov" target="_parent">LCOV version 2.0-1</a></td></tr>
          </table>
          <br>

</body>
</html>
